Apuntes de R 0. Inicio 25/09/2007 20:50:00
← 0. R es un lenguaje de programación y cálculo, como MatLab o GNU,
cuyos antecesores son los paquete de cálculos estadísticos S, SSPS, S++. R
funciona mediante una cónsola y diferentes ventanas donde se presentan las
tareas que están siendo ejecutadas en un momento dado. La diferencia
principal entre R y los paquetes de la familia S es que los comandos de éstos
producen y almacenan buena parte de los cálculos intermedios entre la data
y el resultado final deseado; mientras que R únicamente almacena y
presenta el resultado final.
←← 1. El “prompt” o señal de que la cónsola espera un comando de
ejecución puede variar según el SO sea UNIX, WINDOWS o MACOS. En estos
apuntes escribimos
← >
← para el prompt. Para ejecutar un comando en la cónsola se escribe el
nombre del comando y a continuación se pulsa ENTER. Por ejemplo,
← > help + ENTER
← que en adelante escribiremos simplemente
← > help
← es un comando que abre la página de ayuda de R. Esta página web
también se puede abrir con del botón de ayuda sobre la barra de
herramientas.
←← 2. Podemos pedir ayuda sobre un comando o paquete particular desde
la cónsola de R mediante dos comandos
← > help(tópico o comando preciso)
← > example(comando o paquete preciso)
←← Por ejemplo
← > help(solve)
← despliega la información sobre el comando solve. Una alternativa es
← > ?solve
←← 3. Al igual que otros paquetes (como LaTeX), el lenguaje R es sensible
a las mayúsculas y signos de puntuación.
←4. Las variables numéricas, literales o lógicas que están siendo usadas en
memoria, constituyen el “espacio de trabajo” de R. Para chequear desde la
cónsola el espacio de trabajo, se emplea el comando
> objects()
Una alternativa es el comando
> ls()
Para remover alguna o todas las varibles utilizadas se emplea
> rm
Apuntes de R – 1. Comandos básicos 25/09/2007 20:50:00
← 1. Vectores: Probar con los siguientes comandos
← > x<-c(1,2,3)
← asigna el nombre x al vector (1,2,3). Para ver la coordenada j del
vector x se escribe
← > x[j]
← > y<- 1:7
← asigna el nombre y al vector de 7 entradas (1...7). Para hacer vectores
con secuencias no enteras se utiliza el comando sec(). Por ejemplo,
← > z<-seq(1,20,by=.5)
← da 40 entradas de 0,5 en 0,5. Para construir un vector que repita
varias veces las coordenadas se usa la función
← >rep(variable,#repeticiones por variable,#repeticiones por vectores).
← Se puede probar con los siguientes comandos
← > c(x,y,0,y)
← > rep(y,3)
← > rep(y,3,25)
← > c(“a”,”b”)[ rep(c(1,2,2,1), times=4)]
←← 2. Operaciones con vectores
← Las variables vectoriales se operan coordenada a coordenada y por
“múltiplos de entradas”, probar
← > x+y
← > x*y
← > 1/x
← > x+2*y
← > x-3
← Las funciones se aplican coordenada a coordenada, por ejemplo,
← > sin(y)
← > exp(x)
← Las funciones tienen nombres en inglés, exp, sin, cos, ln, sqrt,
etcétera.
← > sum(y)
← da la suma de las 30 entradas de y, sum(x) da 1+2+3=6. Del mismo
modo, > prod(y)
← da el producto de las entradas del vector y.
←← 3. Funciones: Para ver una coordenada de un vector-variable se
utilizan corchetes. x[2] es la segunda coordenada del vector-variable x. De
este modo se pueden utilizar sólo algunas coordenadas o entradas de un
vector-variable. Por ejemplo:
← > q<-1:10
← > q[1:5]
← > exp(-q)[1:5]
←← La raíz cuadrada se puede tomar compleja o real. Si escribimos
← > sqrt(-17)
← obtendremos un NAN (Not Available Number, número no disponible).
Para obtener la raíz compleja debemos escribir
← > sqrt(-17+0i)
←← 4. Definir funciones: Uno puede definir sus propias funciones. Por
ejemplo
← > f<-function(x,y) x/(1+y^2)
← > f(1:10,10:1)
← Como otro ejemplo, una manera de definir el producto escalar entre
dos vectores (de igual longitud) es mediante
← > f<-function(x,y) sum(x*y)/length(x*y)
←←← 5. Graficar: El nombre del número real Pi es “pi”; probar el siguiente
comando
← > u<-seq(0,2*pi,by=0.1)
← > plot(sin(u),cos(u))
← que da como resultado el gráfico de un círculo unitario (ver ficha de
Graficar).
←← 6. Resumen estadístico:
← >Summary(x)
← es el primer comando estadístico de R que veremos en estos apuntes.
Provee un resumen de los estadísticos de la variable aleatoria x, cuartiles,
media, mediana, mínimo y máximo.
←←
Apuntes de R – 2. Graficación (I) 25/09/2007 20:50:00
← 1. El comando básico para graficar es plot(horizontal, vertical) donde
en “horizontal” debe ir una variable independiente y en “vertical” una
variable dependiente. Es decir, este comando plot es para graficación
explícita, no para variables implícitas.
←← Se puede probar con los siguientes comandos
←← > x<-seq(-5,5,by=.01)
← > plot(x,sin(x))
← > plot(x,cos(x),type="l")
←←← > plot(x,exp(x))
← > plot(x,x^2)
← > plot(x,tan(x))
← > plot(x,log(x))
← > plot(x,3*x-1+exp(-x^2))
← > plot(x,3*x-1+1.5*exp(-x^2))
← > plot(x,3*x-1+6*exp(-x^2))
← > plot(x,3*x-1+10*exp(-x^2))
←←← 2. Para graficar es mejor evitar los valores NA (ver ficha de comandos
básicos). Una buena opción es eliminarlos con un comando lógico de
argumento opcional, por ejemplo
←
← > x<-1:30
← > u<-(2*log(x)-3)[(!is.na(x)) & x>.2]
← > plot(x,u)
← Para ver en una tabla los valores de las horizontales y las verticales se
utiliza el comando data.frame(); por ejemplo
← > data.frame(sin(u),cos(u))
← da como resultado una que contiene los 63 pares coordenados de la
gráfica anterior.
←← Para dibujar curvas implícitas en R2, como las cónicas, se suelen
emplear coordenadas polares. Probar la siguiente secuencia de comandos
← > u<-seq(0,2*pi,by=0.1)
← > plot(sin(u),cos(u))
←← Se pueden cambiar los parámetros de un dibujo con
← par(...)
← Algunos parámetros son:
← bg=”...” (back ground) determina el color del fondo
← bty=”...” (box type) determina el gráfico de la caja de coordenadas, los
tipos son "o", "l", "7", "c", "u", or "]". El tipo “n” suprime la
caja.
← cex=... determina la escala numérica del dibujo.
← cex.axis= escala de las letras de los ejes
← cex.lab= escala de las estiquetas de los ejes
← cex.main= escala del texto principal
← cex.sub= escala del subtítulo
← col=”...” color para el dibujo. Del mismo modo hay col.axis, col.lab,
col.main, col.sub.
← fg=”...” (fore ground) color del primer plano de puntos a graficar
← ljoin=”...” (line join) para junta entre líneas, “round”=círculo abierto,
“mitre”=punto ingleteado, “bevel”=biselado
← lty=”...” (line type) tipo de línea, los tipos son “blank” (no pinta las
líneas), “solid" (línea recta continua), "dashed" (segmentada)
"dotted" (punteada) "dotdash"(punto-segmentada), "longdash"
(segmentos más largos).
← lwd=... (line width) grosor de la línea, el argumento es un entero, el
valor por defecto es 1.
← new=TRUE/FALSE parámetro lógico. Si se le asigna el valor TRUE
entonces el próximo gráfico no debería borrar al existente, sino comenzar a
graficar como si el espacio del dibujo estuviese limpio (“nuevo”).
← pty=”...” (point type) el tipo de punto puede ser
←← Por ejemplo,
← par(cex=.4)
← x<-seq(-5,5,by=0.01)
← Col<-c("blue","red","yellow","green","black","magenta")
← for (n in 1:6) {par(col=Col[n])
← plot(x,sin(n*x),type=”l”)
← par(new=TRUE)}
←← Para dibujar una cadena finita de Markov de 100 pasos, con paso
aleatorio entre los puntos equiprobables (+-1,0) y (0,+-1), tenemos el
siguiente algoritmo
←← par(bg="white",col="blue")
← T<-(1/2)*pi*sample(1:4, 100, replace = TRUE, prob =
c(1/4,1/4,1/4,1/4))
← u<-array(0,c(100,2))
← for (n in 1:100) u[n,]<-c(cos(T[n]),sin(T[n]))
← p<-array(0,c(101,2))
← for (n in 2:101) {p[n,]<-p[n-1,]+u[n-1,]}
← plot(p[,1], p[,2])
← polygon(p[,1], p[,2], col= 'pink')
←← Este es un dibujo de segmentos y flechas
← x <- runif(12); y <- rnorm(12)← i <- order(x,y); x <- x[i]; y <- y[i]← plot(x, y, main="arrows(.) and segments(.)")← ## draw arrows from point to point :← s <- seq(length(x)-1)# one shorter than data← arrows(x[s], y[s], x[s+1], y[s+1], col= 1:3)← s <- s[-length(s)]← segments(x[s], y[s], x[s+2], y[s+2], col= 'pink')
←
Apuntes de R – 3. Valores lógicos y literales25/09/2007 20:50:00
← 1. Valores lógicos: son cuatro.
← T=true=cierto,
← F=falso,
← NA=not available=no disponible,
← NAN=not available number=número no disponible,
← Ojo: Los dos últimos no son iguales.
←← 2. Operadores lógico-matemáticos: son ==igualdad exacta, < menor,
> mayor, <= menor o igual, >=mayor o igual, y != para desigual o distinto.
Por ejemplo, si x<-1:10 entonces el comando sin(x)>0 devuelve diez valores
lógicos T F o NA según los valores de las coordenadas de x. El comando
is.na(ln(x)) pregunta, en cada coordenada, si el valor ln(x) no está
disponible. Por ejemplo,
← > z<-c(log(-5:5))
← > y<-z[is.na(z)]
← > w<- z[!is.na(z)]
← > u<-(z+1)[(!is.na(z)) & z>0]
←←← 3. Reemplazar valores NaN:
← Si un vector x tiene coordenadas con el valor NaN, éstas se pueden
reemplazar.
← > x[is.na(x)] <- 0
← Si un vector y tiene coordenadas negativas, éstas se pueden
reemplazar por su valor absoluto. Probar
← > y[y < 0] <- -y[y < 0]
← o bien, la alternativa
← > y <- abs(y)
←← 4. Etiquetas literales: Se pueden poner etiquetas literales a las
variables de los vectores. Probar con los siguientes comandos:
← > etiquetas<-paste(c("pepe","paco","manolo"),1:10,sep=" ")
← > etiquetas
← La salida es
← [1] "pepe 1" "paco 2" "manolo 3" "pepe 4" "paco 5" "manolo 6"
"pepe 7" "paco 8" "manolo 9" "pepe 10"
←← Los valores literales se pueden clasificar a su vez con otras etiquetas
literales. Por ejemplo:
← > names(fruit) <- c("orange", "banana", "apple", "peach")
← > lunch <- fruit[c("apple","orange")]
← > lunch
← apple orange
← 1 5
←
Apuntes de R - 4. Atributos y clases 25/09/2007 20:50:00
← 1. Atributos de un objeto: Las unidades básicas que opera R se llaman
“objetos” y cada objeto tiene atributos asignados.
← Los vectores son objetos con dos atributos: el “modo” y la “longitud”.
Los valores de un vector tienen todos el mismo tipo modo. Hay cuatro
modos de valores/vectores: Lógicos, numéricos, complejos y literales. Se
puede chequear los atributos de un objeto en la cónsola
← > mode(objeto)
← > lenght(objeto)
← > attributes(objeto)
←← 2. Cambio de atributos: Hay comandos para cambiar los atributos de
un objeto. Probar
← > z <- 0:9
← > digits <- as.character(z)
← > d <- as.integer(digits)
←← Incluso un objeto “vacío” debe tener modo, por ejemplo
← > e <- numeric()
← > f <-character()
← Etc. Una vez definido un objeto, el mismo se puede extender
añadiendo coordenadas. Por ejemplo
← > e[3] <- 17
← convierte a e en un vector de longitud 3, cuyas dos primeras
coordenadas son NaN.
← Igualmente se puede recortar la longitud de un vector
← > z <- z[2 * 1:5]
← convierte a z en un objeto de 5 entradas, que guarda las coordenadas
pares del vector anterior (los valores anteriores no son retenidos). Otra
manera de recortar o agrandar vectores es afectar directamente la longitud:
← > length(z) <- 3
←← 3. Clases de objetos: Cada objeto manejado por R tiene una clase, la
cual se puede chequear en cónsola con la función
← > class(objeto)
← Las clase de un objeto puede ser vector, list (lista), array (arreglo),
matrix (matriz), factor y data.frame (tabla de datos que se usa para
graficar); entre otras.
Apuntes de R - 5. Categorizar datos 25/09/2007 20:50:00
← 1. Para categorizar datos se emplean vectores de etiquetas literales y
luego se pueden extraer las distintas etiquetas. Por ejemplo, supongamos
tenemos el vector
←← > hemo<- (8.427885, 8.000042, 11.047349, 8.307965, 8.593702,
8.385527 8.452119, 10.416440, 8.635803, 8.500829, 10.542262,
11.747262, 11.585744, 10.533605, 9.655760, 11.755239, 11.305091,
8.737905, 8.888192, 8.071025, 9.318215, 11.980419, 10.043428,
11.876826, 10.498559, 9.455843, 10.696550, 8.006800, 10.229528,
8.079028)
←← que corresponde a los niveles de hemoglobina de 30 personas, cuyos
sexos y clase económica son respectivamente
←← >
sexo<-c("m","f","f","m","f","m","f","m","m","f","f","f","m","m","f","m","f","m",
"m","f","f","m","m","f","m","m","m","f","f","f")
←← >
clase<-c("F","E","D","E","A","E","C","F","E","F","D","B","B","C","E","F","C","A",
"B","C","D","B","F","E","F","C","D","B","E","F")
←← Para manejar las categorías literales como factores escribimos
← > sexof<-factor(sexo)
← > clasef<-factor(clase)
←← El vecto sexof es el mismo vector sexo, cuyas etiquetas literales ahora
son factores o símbolos, que además han sido contabilizados por “niveles”.
Para ver el número de etiquetas de una categorización se escribe, por
ejemplo
←← > Levels(sexof)
←
← 2. Las categorías convertidas a factores (o etiquetas) sirven para
categorizar los datos y procesarlos según esas etiquetas. Si ahora
quisiéramos conocer las medias de niveles de hemoglobina por sexos,
empleamos el comando tapply() del modo siguiente:
←← > mediahemosex<-tapply(hemo,sexof,mean)
← > mediahemosex
← para ver las medias de la misma data categorizada por clase social
escribimos
←← > mediahemoclase<-tapply(hemo,clasef,mean)
← > mediahemoclase
← El último argumento puede ser cualquier función que se aplique a un
grupo de datos como la media (mean) o la varianza (var). Prueba con
←← > varhemoclase<-tapply(hemo,clasef,var)
← > varhemoclase
←← Uno también puede aplicar funciones construidas por uno mismo, por
ejemplo el error medio estandar de un vector de datos es
← > Ems<- function(z) sqrt(var(z)/length(z))
← > Emshemosex<-tapply(x,sexof,Ems)
← > Emshemosex
Apuntes de R – 6. Estadísticos Básicos (I) 25/09/2007 20:50:00
← 1. Números aleatorios: El comando rnorm(k) provee un vector con k
entradas aleatorias. La distribución de rnorm() es una gaussiana estándar.
Por ejemplo
← > x<-rnorm(100)
← asigna a la letra x un vector de 100 entradas aleatorias. Cada vez que
se ejecuta el comando, cambian los valores de las entradas.
← >summary(x) provee un resumen de los estadísticos elementales de x,
considerada como una V.A. con 100 ocurrencias.
←← 2. Importar datos: Uno puede importar datos de una tabla. Por
ejemplo; consideremos las variables
← x <- 1:20
← > w <- 1 + sqrt(x)/2
← El comando
← > Tabla <- data.frame(x=x, y= x + rnorm(x)*w)
← crea una tabla (data.frame) en la cual la columna y es una nueva
variable que toma los valores de x perturbados por un valor aleatorio que
depende de los valores de w. Esta tabla se almacena completamente en una
nueva variable llamada Tabla. Ahora se pueden importar los datos de esta
tabla para procesar sus estadísticos:
← > fm <- lm(y ~ x, data=Tabla)
← > summary(fm)
← Los valores de los estadísticos que arroja el último comando cambian
cada vez que ejecutamos el bloque de sentencias.
←← Para importar datos de una tabla se emplean tres comandos:
← > system.file(); este comando busca el archivo deseado,
← > file.show; este comando muestra (despliega) la tabla elegida, y
← > read.table; este comando extrae los valores de la tabla para
asignarlos a una nueva variable. Para ver un ejemplo, se puede ejecutar la
siguiente lista de comandos:
←← > filepath <- system.file("data", "morley.tab" , package="datasets")
← Éste es el camino o ubicación del archivo.
← > file.show(filepath)
← Esto despliega la tabla-archivo que se halla en el camino anterior.
← > Tabla<-read.table(filepath)
← Esto extrae los datos de la tabla y los envía a la variable aleatoria
Tabla. Si se quiere ver los archivos de la tabla se puede escribir
← > Tabla
←← A continuación se
← > Tabla$Expt <- factor(Tabla$Expt)
← > Tabla$Run <- factor(Tabla$Run)
← > attach(mm)
← > plot(Expt, Speed, main="Speed of Light Data", xlab="Experiment
No.")
← > frec <- aov(Speed ~ Run + Expt, data=mm)
← > frec0 <- update(frec, . ~ . - Run)
← El gráfico anterior, en efecto, es el de un experimento sobre la
velocidad de la luz...
←← 3. ANOVA: Para realizar el análisis de variabilidad se ejecuta el
comando
← > anova(fm0, fm)
← Para terminar la sesión se escribe
← > detach()
← > rm(frec, frec0)
←← Este es otro ejem. De graficación:
← > detach()
← > rm(fm, fm0)
← > x <- seq(-pi, pi, len=50)
← > y <- x
← > f <- outer(x, y, function(x, y) cos(y)/(1 + x^2))
← > oldpar <- par(no.readonly = TRUE)
← > par(pty="s")
← > contour(x, y, f)
←←← 4. REGRESIÓN: Para ver cómo R realiza una regresión lineal sobre la
variable, ejecuta los siguientes comandos
← > plot(x, y)
← > lrf <- lowess(x, y)
← > lines(x, lrf$y)
← > abline(0, 1, lty=3)
← > abline(coef(fm), col = "red")
←← Para comparar error versus los ajustes,
← > plot(fitted(fm), resid(fm),
← + xlab="Valores ajustados", (los signos + los
pone R
← + ylab="Residuos", automáticamente)
← + main="Residuos vs Ajustes")
←←← La bondad del ajuste depende de cómo la siguiente gráfica se acerca a
la recta bisectriz:
> qqnorm(resid(fm), main="Rankit Plot de Residuos")
←
Apuntes de R – 7. Arreglos y matrices 25/09/2007 20:50:00
← 1. Arreglos: Los arreglos son generalizaciones de vectores. Para
generar arreglos con R se emplea el comando
← > array(obj,tam)
← donde obj=un objeto o lista de datos y tam=tamaño o dimensión del
arreglo en filas x columnas. La sintaxis adecuada de este comando es como
sigue:
←← > x <- array(1:20, dim=c(4,5))
←← asigna al objeto x un arreglo matricial de 4 filas x 5
columnas,en las cuales se disponen los números del 1 al 20.
Uno puede asimismo llamar a las entradas, filas y columnas
del arreglo;
← > x[2,3] llama a la posición (2,3)
← > x[2,] llama a la fila 2
← > x[,3] llama a la columna 3
←← En los índices de los arreglos podemos usar otros arreglos como
argumentos. Probemos con
←← > i <- array(c(1:3,3:1), dim=c(3,2))
← > i
← > x[i]
←← También podemos cambiar los datos de una entrada particular de la
matriz, por ejemplo
←← > x[,1] <- 0
←
← Manda a cero todos los valores de la primera columna.
←← 2. Crear arreglos: Se pueden crear arreglos con listas de datos, he aquí
dos maneras de arreglar un vector de 24 entradas aleatorias:
←← > z<-rnorm(24)
← > Z<-array(z,dim=c(3,2,4))
← > ZB<-array(z,dim=c(6,4))
←← Si la longitud del vector original de datos no coincide con la dimensión
del arreglo, entonces al hacer el arreglo o bien se trunca la lista (si la
dimensión es menor) o bien se vuelve a comenzar la lista (si la dimensión es
mayor).
←← > u<-rnorm(24)
← > v<-1:15
← > U<-array(u,dim=c(5,4))
← > V<-array(v,dim=c(5,4))
←← 3. Operaciones: Las operaciones con arreglos requieren que los
arreglos tengan igual dimensión; probar con
←← > 2*U-1
← > U + V
← > U * V
←
← 4. Producto exterior: Dados dos arreglos A B de dimensiones
respectivas a,b (donde la dimensión de un arreglo es un vector), el producto
exterior de A por B produce un nuevo arreglo de dimensión (a,b) cuyas
entradas se producen coordenada a coordenada. Probar
←← > A<-1:4
← > U %o% A
← > A %o% U
←← Una alternativa para A %o% U es escribir
←← > outer(A,U,*)
←← El último argumento es una función (en este caso el producto usual *),
pero se puede poner cualquier otra función de dos argumentos f(x,y).
Pruébese por ejemplo con
←← > f<-function(x,y) x/(1+y^2)
← > outer(U,A,f)
←← 5. Arreglos traspuestos y permutados: En R hay un comando
←← > aperm(arreglo, perm)
←← que produce una permutación del arreglo según los índices. Si A es un
arreglo de dimensión d, donde a su vez d es un vector de longitud = k; y
pensamos en cualquier permutación de k enteros como un vector s de
longitud k cuyas entradas son precisamente los enteros 1...k; entonces el
comando
←
← > B<-aperm(A,s)
←← produce un nuevo arreglo cuyas entradas satisfacen
← B[s[j[1]],..,s[j[k]]]=A[j[1],..,j[k]] . En particular, el traspuesto de un
arreglo de dos dimensiones (un arreglo “matricial”) A se obtiene mediante el
comando
←← > B <- apero(A, c(2,1))
← Se puede utilizar, en este caso, el comando resumido
← > B <- t(A)
←← 3. Regla de reciclaje de datos:
← i) Toda lista de datos (vector) se lee de izquierda a derecha. Los datos
se vacían de arriba abajo y de izquierda a derecha; es decir, en ORDEN
LEXICOGRÁFICA.
← ii) Todo vector demasiado corto se extiende reciclando sus valores, se
vuelve a leer la lista desde el principio hasta completar la dimensión total del
arreglo.
← iii) Sólo se admiten operaciones entre arreglos con la misma
dimensión.
← Todo vector más largo que una matriz o arreglo sobre el cual opera
genera un error.
←← Esta regla de reciclaje de datos es seguida por R por “defecto”, vale
decir, automáticamente, a menos que se le especifique lo contrario. Para
comprender mejor la manera en que opera dicha regla compárese la manera
de definir las siguientes funciones: Definamos la función
← > f<- function(x,y) sin(x*y)
←← Puesto que el argumento es bilineal, la función f(x,y) es simétrica
(aunque no es bilineal pues la función trigonométrica sin(---) elimina la
linealidad. Esta función (y cualquier otra construida del mismo modo) se
puede emplear para producir matrices simétricas con el comando
← > N<-outer(1:5,1:5,f)
←
← Un error común es pensar que dicha orden es equivalente a
← > M<-array(f(1:5,1:5),dim=c(5,5))
←← Mientras la primera secuencia produce una matriz simétrica, la
segunda produce una matriz que repite la misma columna 5 veces. Una
manera alternativa de obtener la segunda matriz es mediante el comando
← > MB<- array(sin((1:5)^2)),dim=c(5,5))
Apuntes de R –8. Matrices 25/09/2007 20:50:00
← En R las matrices son arreglos 2-dimensionales, es decir, arreglos A
tales que su dimensión d=dim(A) es un vector de longitud 2.
←← 1. Suma: Se hace igual que con los arreglos, A+B es la suma matricial
coordenada a coordenada.
←← 2. Producto: El producto matricial se escribe %*% para distinguirlo del
producto coordenada a coordenada *. Por ejemplo, si X es un vector de
longitud n y A es una matriz cuadrada nxn, entonces X %*% A %*% X es una
forma cuadrática.
←← 3. Trasposición: Como ya se dijo (ver Arreglos), la traspuesta de A se
obtiene con el comando t(A).
←← 4. Diagonal: La diagonal de una matriz A (cuadrada o no), es el vector
que se extrae de los coeficientes de la forma A[j,j]; y se obtiene con el
comando diag(A). Por otra parte, si v es un vector de longitud n; entonces
diag(v) produce una matriz diagonal cuya diagonal es, precisamente, el
vector v.
←← 5. Inversas y sistemas de ecuaciones: La inversa de una matriz
cuadrada A se calcula mediante el comando
←← > solve(A)
←← Sin embargo, el cálculo de inversas matriciales es inestable en R. Dado
un vector b, el sistema Ax=b en R se escribe del modo siguiente
← > x<- A %*% b
←← Para resolver dicho sistema se emplea el comando
← > x<-solve(A,b)
← Este comando es más estable numéricamente que la orden
← > x<-solve(A) %*% b
←← 6. Autovalores: El comando
← > Aut<-eigen(M)
← calcula los autovalores y autovectores de una matriz simétrica M, y los
asigna a un arreglo Aut. El resultado es una lista de dos componentes,
llamados “values” (valores) y “vectors” (vectores).
← > f<-function(x,y) exp(-(x^2)*(y^2))
← > O<-outer(1:10,1:10,f)
← > Aut<-Eigen(O)
←← Para obtener una sola de las componentes, digamos los autovalores,
escribimos
← > Aut$val
← > Aut$vec
←← Otra manera es
← > Autval <- eigen(Sm)$values
←← Para matrices demasiado grandes, si se quiere ahorrar tiempo
evitando que R calcule los autovectores, se puede emplear una variante. Por
ejemplo
← > u<-seq(-10,10,by=.01)
← > P<-outer(u,u,f)
← produce una matriz simétrica de 1000x1000. Aunque R es capaz de
calcular autovalores y autovectores (pruebe eigen(P) si se atreve...) la lista
de retorno es demasiado grande. Una buena alternativa es
← > Autval <- eigen(P, only.values = TRUE)$values
←
← -------------POR TRADUCIR--------------
←← 5.7.5 Least squares fitting and the QR decomposition
←← The function lsfit() returns a list giving results of a least squares fitting
procedure. An assignment such as
←← > ans <- lsfit(X, y)
← gives the results of a least squares fit where y is the vector of
observations and X is the design matrix. See the help facility for more
details, and also for the follow-up function ls.diag() for, among other things,
regression diagnostics. Note that a grand mean term is automatically
included and need not be included explicitly as a column of X. Further note
that you almost always will prefer using lm(.) (see Linear models) to lsfit() for
regression modelling.
←← Another closely related function is qr() and its allies. Consider the
following assignments
←← > Xplus <- qr(X)
← > b <- qr.coef(Xplus, y)
← > fit <- qr.fitted(Xplus, y)
← > res <- qr.resid(Xplus, y)
← These compute the orthogonal projection of y onto the range of X in fit,
the projection onto the orthogonal complement in res and the coefficient
vector for the projection in b, that is, b is essentially the result of the Matlab
`backslash' operator.
←← It is not assumed that X has full column rank. Redundancies will be
discovered and removed as they are found.
←← This alternative is the older, low-level way to perform least squares
calculations. Although still useful in some contexts, it would now generally be
replaced by the statistical models features, as will be discussed in Statistical
models in R.
←
← 5.8 Forming partitioned matrices, cbind() and rbind()
←← As we have already seen informally, matrices can be built up from
other vectors and matrices by the functions cbind() and rbind(). Roughly
cbind() forms matrices by binding together matrices horizontally, or
column-wise, and rbind() vertically, or row-wise.
←← In the assignment
←← > X <- cbind(arg_1, arg_2, arg_3, ...)
← the arguments to cbind() must be either vectors of any length, or
matrices with the same column size, that is the same number of rows. The
result is a matrix with the concatenated arguments arg_1, arg_2, ... forming
the columns.
←← If some of the arguments to cbind() are vectors they may be shorter
than the column size of any matrices present, in which case they are
cyclically extended to match the matrix column size (or the length of the
longest vector if no matrices are given).
←← The function rbind() does the corresponding operation for rows. In this
case any vector argument, possibly cyclically extended, are of course taken
as row vectors.
←← Suppose X1 and X2 have the same number of rows. To combine these
by columns into a matrix X, together with an initial column of 1s we can use
←← > X <- cbind(1, X1, X2)
← The result of rbind() or cbind() always has matrix status. Hence
cbind(x) and rbind(x) are possibly the simplest ways explicitly to allow the
vector x to be treated as a column or row matrix respectively.
←← 5.9 The concatenation function, c(), with arrays
←
← It should be noted that whereas cbind() and rbind() are concatenation
functions that respect dim attributes, the basic c() function does not, but
rather clears numeric objects of all dim and dimnames attributes. This is
occasionally useful in its own right.
←← The official way to coerce an array back to a simple vector object is to
use as.vector()
←← > vec <- as.vector(X)
← However a similar result can be achieved by using c() with just one
argument, simply for this side-effect:
←← > vec <- c(X)
← There are slight differences between the two, but ultimately the choice
between them is largely a matter of style (with the former being preferable).
←← 5.10 Frequency tables from factors
←← Recall that a factor defines a partition into groups. Similarly a pair of
factors defines a two way cross classification, and so on. The function table()
allows frequency tables to be calculated from equal length factors. If there
are k factor arguments, the result is a k-way array of frequencies.
←← Suppose, for example, that statef is a factor giving the state code for
each entry in a data vector. The assignment
←← > statefr <- table(statef)
← gives in statefr a table of frequencies of each state in the sample. The
frequencies are ordered and labelled by the levels attribute of the factor.
This simple case is equivalent to, but more convenient than,
←← > statefr <- tapply(statef, statef, length)
← Further suppose that incomef is a factor giving a suitably defined
“income class” for each entry in the data vector, for example with the cut()
function:
←
← > factor(cut(incomes, breaks = 35+10*(0:7))) -> incomef
← Then to calculate a two-way table of frequencies:
←← > table(incomef,statef)
← statef
← incomef act nsw nt qld sa tas vic wa
← (35,45] 1 1 0 1 0 0 1 0
← (45,55] 1 1 1 1 2 0 1 3
← (55,65] 0 3 1 3 2 2 2 1
← (65,75] 0 1 0 0 0 0 1 0
← Extension to higher-way frequency tables is immediate.
Apuntes de R –9. Listas 25/09/2007 20:50:00
← 1) Qué es una lista? Una lista es una colección de objetos,
categorizados por nombres, llamados “componentes”, que pueden ser
diferentes.
← > Lista <- list(nombre=”Juan”, esposa=”María”,
no.hijos=3,edad.hijos=c(2,4,5))
← Las componentes están numeradas por orden de aparición y se les
llama individualmente
← > Lista[[1]]
← El número de componentes de una lista lo da el comando
← > length(Lista)
← Si uno olvida el número de una componente la puede buscar por su
nombre
← > Lista$esposa
← y las componentes se pueden almacenar en otros vectores
← x<-Lista$edad.hijos
←← 2. Construir una lista: Se hace con el comando
← > Lst <- list(nombre1=objeto_1, ..., nombre_m=objeto_m)
← Si omitimos los nombres, las componentes sólo se pueden especificar
por números. Los objetos asignados a una lista son COPIADOS, de modo que
los originales no son afectados. Una lista puede ser extendida añadiendo
componentes nuevas
← > Lista[5] <- list(matrix=Mat)
← O por concatenación de listas
← ListaABC<-c(lista.A, lista.B, lista.C)
Apuntes de R –10. Archivos de datos 25/09/2007 20:50:00
Una lista de datos es una lista clasificada como “data.frame”. Las listas de
datos tienen restricciones:
• Las componentes son vectores, factores, matrices u otros archivos
de datos.
• Los valores numéricos, lógicos o factores no se alteran. Los valores
literales (caracteres) se CONVIERTEN EN FACTORES.
• Los vectores que forman un archivo de datos (data.frame) tienen la
MISMA LONGITUD y las matrices tienen todas FILAS DE IGUAL
LONGITUD.
←← Una lista cualquiera L1que satisface las propiedades anteriores puede
ser realmacenada o leída como data.frame mediante el comando
← > L2<-As.data.frame(L1)
← Para crear una data.frame se utiliza el comando data.frame. Por ejem,
← > Diario<-data.frame(casa=statef, lote=ingresos, saldo=ingresosf)
←← Añadir y quitar:
← Se pueden añadir listas nuevas a las que se manejan actualmente
mediante el comando
← > attach(cualquier lista vieja)
← Todo lo que ha sido añadido puede luego ser retirado también,
mediante el comando
← > detach(lo que quiera retirar)
←← Para trabajar con archivos de datos (data.frame) es útil tener en
cuenta las siguientes recomendaciones:
• Dado un problema bien definido, junta todas las variables del
problema en una data.frame con un nombre adecuado.
• Al trabajar con un problema de tipo funcional, es mejor dejar la
variable independiente en la posición de la 1ra componente, y la
dependiente en la 2da posición.
• Antes de cerrar un problema, identifica las variables que quieres
conservar en el futuro. Añádelas a la data.frame con asignaciones $
y luego aplica el comando detach(-).
• Borra o remueve todas las cantidades no deseadas del directorio de
trabajo y manténlo limpio de variables temporales, en la medida de
lo posible.
←
Apuntes de R – Leer listas 25/09/2007 20:50:00
← Para leer datos de una lista, ésta debe tener una forma precisa:
← La primera fila debe contener un NOMBRE para cada variable
(columna).
← Cada fila adicional debe tener, como primer elemento, una ETIQUETA
de la fila, y luego los valores de cada variable.
←
← Para leer una lista como arriba se emplea el comando
← > MedidaCasa <- read.table(“MedidaCasa.data”)
← Si queremos obviar las etiquetas de las filas e ingresar la tabla como
←←
←← se puede hacer con el comando
← > MedidaCasa <- read.table(“MedidaCasa.data”, header=TRUE)
←←←←
Apuntes de R – Comandos de Ejecución 25/09/2007 20:50:00
← R es un lenguaje de programación y cálculo en el cual toda expresión
(simbólica) es se puede agrupar. Los signos de agrupación en R son los
usuales de Matemáticas: Corchetes [], paréntesis () y llaves {}.
←← 1. Las expresiones o comandos se agrupan con paréntesis o llaves. Los
corchetes se emplean para evaluar coordenadas de vectores o tablas.
←← 2. Cada comando ejecutable devuelve un valor o resultado. El ejemplo
más sencillo de un comando ejecutable es una asignación del tipo x<-1:5; el
resultado en este caso es el valor asignado, que puede ser empleado
ulteriormente.
←← 3. Los comandos se suelen agrupar con llaves del modo
← {expr_1; ...; expr_m}
← El valor de un grupo de expresiones es el resultado de la última
expresión del grupo. Cada grupo de expresiones es, a su vez, una nueva
expresión o comando que puede, a su vez, se incluida entre paréntesis y ser
empleada como parte de una expresión o comando más largo.
←← 4. Ejecución condicional: Es una construcción de la forma
←← > if (expr_1) expr_2 else expr_3
←← donde expr_1 es una expresión de valor lógico simple (no vectorial).
←← Con frecuencia se emplean las abreviaturas &&, || como parte de la
condición. Mientras que los símbolos &, | afectan a vectores (coordenada a
coordenada); los símbolos && y || en cambio afectan a constantes (vectores
de longitud 1) y únicamente evalúan el segundo argumento si es necesario.
←← Una alternativa es el condicional “vectorizado”
←← >ifelse(condition, a, b)
←← que devuelve un vector de la longitud del (vector más largo del)
argumento, con elementos “a[i] if condition[i] is true, otherwise b[i]”.
←← 5. Lazos y ejecución repetida: Se construyen con el comando
←
← > for (N in expr_1) expr_2
←← donde N es la variable contador del lazo, expr_1 es una
expresión/vector (usualmente una secuencia como 1:20), y expr_2 es
usualmente una expresión agrupada cuyas sub-expresiones se escriben en
terminos del contador N. Esta expr_2 es repetidamente evaluada mientras el
contador N corre por la secuencia del vector expr_1.
←← Como ejemplo, supongamos que “ind” es un vector de indicadores de
clase y que queremos producir gráficos separados de y en función de x a lo
largo de las clases. Una posibilidad es emplear el comando “coplot(---)” lo
cual produciría un arreglo de dibujos correspondientes a cada nivel de los
factores/categorías. Otra manera de hacer esto es colocar todos los gráficos
en un “display” como sigue
←← > xc <- split(x, ind)
← > yc <- split(y, ind)
← > for (i in 1:length(yc)) {
← plot(xc[[i]], yc[[i]]);
← abline(lsfit(xc[[i]], yc[[i]]))
← }
←← Notemos que la función “split(---)” produce una lista de vectores
obtenidos mediante la truncación de vectores largos de acuerdo con las
clases especificadas por los factores/categorías. Esta es una función útil,
mayormente empleada junto al comando “boxplots”.
←
← Nota: Los lazos “for(---)” se emplean en R con menos frecuencia que
en lenguajes compilados, pues los lazos que toman un “objeto” dependiendo
de un contador N, en R, se suelen escribir y ejecutar de manera más rápida.
Otras facilidades tipo lazos son
←← > repeat expr
← > while (condition) expr
←← El comando
←← > break
←← se emplea para terminar cualquier lazo, incluso de manera anormal, y
es el único modo de finalizar los lazos que se construyen con el comando
“repeat”. El comando
←← > next
←← se emplea para romper ciclos particulares y saltar al ciclo “siguiente”.
Las secuencias para controlar lazos se suelen construir a través de
funciones.
←← Caminata aleatoria
> m<- readline(“Número de ramas del grafo = ?”) % OJO CON LAS
COMILLAS!!
← > n<- readline(“Número de pasos de la caminata = ?”)
← > M<- as.integer(m)
← > N<- as.integer(n)
← >Arg<-(2*pi/M)*floor(runif(N,0,M))
← >hor<-cos(Arg) % mov. Aleat. Horizontal
← >ver<-sin(Arg) % mov. Aleat. Vertical.
← >C<-0
← >length(C)<-2*(N+1)
← >dim(C)<-c(N+1,2)
← > C[1,1]<-0
← > C[1,2]<-0
← > for (k in 1:N) (C[k+1,1]<-C[k,1]+hor[k])
← > for (k in 1:N) (C[k+2,1]<-C[k,2]+ver[k])
← > plot(C) % pasos aleatorios de la caminata (gráfico de saltos
aleatorios)
← > x<-seq(0,1,by=.01) % variable de las combinaciones convexas
← > u<-0
← > length(u)<-2*(N+1)*length(x)
← >D<-0
← >length(D)<- 2*(N+1)
← >dim(D)<-c(N+1,2)
← >for (k in 1:N) (D[k,]<-C[k+1,])
← > u<-array((1-x)%o%C+x%o%D, dim=c((N+1)*length(x),2))
← > plot(u, type="l", col="magenta") %gráfico de la caminata continua)
←←