Emacs-snapshot

He estado a punto de titular este artículo Pretty emacs, como el artículo de Alexandre Vassalotti. Creo que es muy acertado, pero he preferido no copiarlo.

Emacs-snapshot es un conjunto de paquetes de la versión CVS de GNU Emacs, el conocido editor (y otras cosas), especialmente concebidos para la distribución de linux Debian y, por extensión, para Ubuntu. Han preparado dos versiones. Una para el sistema gráfico GTK y la otra para la consola. Yo utilizo la primera.
A poco que se navegue un poco por la red, todo el mundo coincide que Emacs es un potentísimo editor (dicen que incluso una forma de vida), pero también hay coincidencia en la dificultad de su aprendizaje. Así, muy pocos serán los que se atreban a probarlo. En Kubuntu hay una alternativa que es RKWard, mucho más sencillo i intuitivo, pero también ligeramente inestable. De modo que yo me animé a probar Emacs-snapshot.

Para trabajar con R, la instalación de Emacs-snapshot es muy sencilla:

sudo apt-get install emacs-snapshot ess

El segundo paquete es Emacs speaks statistics, imprescindible para que Emacs y R se entiendan (se supone que R está instalado).
Con esta instrucción se instalaran las versiones de los repositorios oficiales de Ubuntu. Si alguien desea lo último de lo último, hay que instalar los repositorios PPA for Ubuntu Emacs Lisp.
Una vez instalados, cuando abrimos un archivo con extensión .R, Emacs-snapshot lo reconoce como tal y la primera vez que utilicemos los botones de ejecución, abrirá una ventana para solicitar la carpeta de trabajo. La fijamos y aparecerá un buffer (ventana en el lenguaje de Emacs) con R en la parte inferior (ver la figura de arriba). En esta situación ya podemos ir ejecutando las instrucciones del archivo y viendo los resultados en el buffer inferior. El sistema es sencillo y muy práctico. Y a partir de aquí, buscar un manual de Emacs o seguir su tutorial. El esfuerzo vale la pena.

Por cierto, ¿a qué viene lo de pretty emacs?

Pues, resulta que es muy fácil cambiar la fuente y poner la que más nos guste. La que viene por defecto suele ser horrorosa. Ver el post de Alexandre Vassalotti.

¿Y los que trabajamos con Windows? Pues a la izquierda tenéis un enlace a la, a mi parecer, más sencilla instalación para Windows.

Disposición de los gráficos (2)

Animado por los comentarios al anterior artículo sobre la disposición de los gráficos con ayuda de la función layout, vamos a seguir explicando otras características de esta función.

Ya indiqué que es posible dejar una casilla en blanco, basta poner un cero en la matriz, pero también es posible controlar las alturas o anchuras en centímetros. Para ello se utiliza la función lcm(). Veamos un ejemplo.

Con este código

> layout(matrix(c(1,0,2), ncol=1), heights=c(2, lcm(0.5), 1))

se consigue esta figura

en el que tenemos 0.5 cm entre los dos gráficos.

Otro aspecto a tener en cuenta es la relación de la altura con la anchura. Si queremos que ésta sea de 1:1, lo podemos indicar con el parámetro respect=T.

> layout(matrix(c(1,0,2), ncol=1), heights=c(2, lcm(0.5), 1), respect = T)

El resultado es

Si en la matriz se repite algún número, entonces el gráfico ocupará esas casillas (consecutivas).
Ejemplo:

> layout(rbind(c(1,2),
              c(0,0),
              c(3,3)),
        heights=c(2,lcm(0.5),1),
        respect=T)

Observemos que en esta figura la relación de aspecto se fija en 1 para la altura de la tercera fila (gráfico 3), de modo que el parámetro respect=T hace que la anchura de una celda de la tercera fila también sea 1 (de las dos que hay).

Finalmente podemos decir que el parámetro respect también admite como valor una matriz del mismo tamaño que la que indica la layout, pero con ceros y un uno. El uno marca la posición de la celda para la que hay que respetar la relación de aspecto.

Más ejemplos e información en el libro de Paul Murrell R Graphics Ed. Chapman & Hall/CRC.

Por cierto, los gráficos que muestran la layout actual se consiguen con la instrucción

> layout.show(n)

donde n es el número máximo de gráficos.

Iconos para carpetas de R

Estos días de vacaciones he aprovechado para estudiar un curso on-line de Gimp (programa GNU para crear gráficos). Es un curso básico pero muy bien hecho que podéis encontrar en el siguiente enlace:

Curso de El Gimp

Como ejercicio, para probar mis conocimientos de capas y manipulación de las mismas, he preparado un icono en formato PNG para el tema Oxigen de KDE 4. Creo que ha quedado bastante digno. Lo podéis utilizar en vuestro sistema operativo Linux con KDE 4 (yo utilizo Kubuntu).

Para aquellos que resisten con Windows XP también he preparado un conjunto de iconos de diferentes tamaños (32x32, 64x64 y 128x128) que podéis descargar del siguiente enlace

folder-R.zipLos iconos de Windows Vista y 7 son más sofisticados. ¿Alguien se anima?

Por cierto, faltaba una versión para la gente que utiliza Gnome en Ubuntu:

Disposición de los gráficos

En el paquete UsingR tenemos la función gráfica simple.hist.and.boxplot que produce la figura que mostramos con el siguiente código:

> simple.hist.and.boxplot function (x, ...)
{
op <- par(no.readonly = TRUE)
on.exit(par(op))
layout(matrix(c(1, 2), 2, 1), heights = c(3, 1))
par(mai = c(1, 1, 1, 1)/2)
hist(x, xlab = FALSE, col = gray(0.95), yaxt = "n", ...)
rug(x)
boxplot(x, horizontal = TRUE)
}

Observemos especialmente que se trata de combinar dos gráficos, el histograma y el boxplot. Pero el detalle que queremos destacar en este artículo es la disposición de los gráficos.

Hay dos parámetros que sirven para disponer varios gráficos en una misma figura. Por ejemplo, en la figura del artículo Chiplot se han dibujado dos gráficos de dispersión en horizontal. Esto se consigue con la instrucción

oldpar <- par(mfrow = c(1,2))

El vector c(nr,nc) especifica el número de filas y de columnas y el parámetro mfrow su escritura (por filas). También hay un parámetro mfcol para escribir por columnas.

Recordar que la modificación de un parámetro es para toda la sesión, de manera que si queremos revertir el cambio debemos ejecutar

par(oldpar)

Sin embargo, estos parámetros sólo dibujan gráficos del mismo tamaño. ¿Cómo se consique una disposición como la del gráfico que encabeza este artículo?



La respuesta es la instrucción layout.

Básicamente, en la instrucción layout debemos especificar una matriz de números correlativos 1,2,... (puede incluir ceros) que indicarán el orden de escritura. Un cero dejará la posición en blanco. La ventaja es que podemos definir las alturas de las filas y las anchuras de las columnas.

Para lograr la disposición de la figura anterior hacemos

> mm <- matrix(c(1,2), nrow = 2)
> layout(mm, heights = c(3,1))

Observemos que la definición de las alturas es proporcional, es decir, el primer gráfico ocupará 3/(3+1) del total, mientras que el segundo 1/(3+1).

Otros detalles de la función layout los dejaremos para otro artículo.

Colores transparentes

En algunas ocasiones puede ser de gran utilidad disponer de colores transparentes. En un gráfico como el de arriba, la acumulación de puntos se hace más visible utilizando un color transparente para los puntos.

La función rgb de definición de un color dispone de un parámetro alpha (entre 0 y 1, por defecto 1) que controla el nivel de transparencia. Por ejemplo, podemos definir un rojo transparente así

> rojo20 <- rgb(1,0,0,0.2)

El gráfico de la figura de arriba es

> plot(rnorm(2000), rnorm(2000), pch=16, col=rojo20, xlab="", ylab="")

También se puede definir un color mediante un código de 8 dígitos hexadecimales que empieza por # y cuyos dos últimos corresponden al valor de alpha. Por ejemplo

> rojo21 <- "#FF000050"

Chiplot

Aunque un gráfico de dispersión (scatterplot) es la primera opción para observar un conjunto bivariante de datos, a veces resulta complicado decidir a primera vista si las variables son independientes o no. Como es lógico nos debemos apoyar en algún contraste estadístico, como el test Ji-cuadrado (discretizando los datos) o el test rho de Spearman, pero también sería de gran ayuda disponer de un gráfico adicional. Éste es el chi-plot de Fisher y Switzer (1985, 2001).

El chi-plot es un gráfico que representa dos variables (lambda y chi) calculadas a partir de los datos muestrales. Tiene la propiedad de que en el caso de que las variables originales sean independientes, los puntos se agrupan en una región central. En caso contrario, si las variables estan relacionadas, los puntos aparecerán fuera de esa región central.

En el gráfico de arriba observamos un conjunto de datos sobre polución que relacionan la cantidad de SO2 con la mortalidad. En el chi-plot apreciamos su dependencia con claridad (rho=0.4915, p-value<0.01).

Fuente: Los datos y la función chiplot se pueden hallar en el libro de B.S. Everitt An R and S-PLUS Companion to Multivariate Analysis y en su web.

Código:
> attach(airpoll)
> chiplot(SO2,Mortality,vlabs=c("SO2","Mortality"))
> cor.test(SO2,Mortality,method="spearman")

Importar datos de una hoja de cálculo

Una de las primeras preguntas de todas las personas que empiezan a trabajar con R es ¿cómo puedo importar mis datos de Excel? La misma pregunta se hacen los que utilizan otras hojas de cálculo como Calc de OpenOffice.org, Gnumeric de Gnome, KSpread de KOffice, etc.

La solución más sencilla consiste en utilizar la función read.table (o sus variantes read.delim y read.csv) para importar una tabla de datos tipo texto. Es decir, previamente debemos guardar la tabla de datos de la hoja de cálculo como un archivo de texto delimitado con tabulaciones o con comas.
Los pasos son los siguientes:

1. Abrir la hoja de cálculo con nuestro programa (Excel, Calc,...) y guardar la hoja activa que contenga la tabla como un archivo de texto delimitado. Podremos elegir el tipo de delimitador (tabulación, coma, punto y coma,...) y el nombre y la extensión del archivo. Por ejemplo, podemos guardar un archivo de texto con el separador "," y el nombre "MiTabla.txt" o "MiTabla.csv" (mejor cuando el separador es "," o ";").
   
   
2. Recuperar la tabla desde la consola de R con la instrucción
   
   > mitabla.df <- read.table("MiTabla.csv", header=T, sep=",")
   
   o también con la instrucción equivalente
   
   > mitabla.df <- read.csv("MiTabla.csv")
   

Cuando el separador es una tabulación, podemos utilizar la instrucción read.delim.

Para todas las personas que tienen la coma "," como separador decimal en sus programas de hojas de cálculo, al guardar el archivo de texto se debe utilizar como separador el punto y coma ";" o la tabulación. Entonces la importación se realiza con las instrucciones:

> mitabla.df <- read.table("MiTabla.csv", header=T, dec=",", sep=";")
o
> mitabla.df <- read.csv2("MiTabla.csv")

Para las tabulaciones es

> mitabla.df <- read.table("MiTabla.txt", header=T, dec=",", sep="\t")
o
> mitabla.df <- read.delim2("MiTabla.txt")

Truco: También es posible recuperar una tabla desde el portapapeles de nuestro sistema operativo con el parámetro file="clipboard" en lugar del nombre del archivo. ¡Pruebalo!

En resumen, hay que guardar la tabla como archivo de texto con separadores y tener en cuenta qué tipo de punto decimal tenemos y qué separador utilizamos.

Para los usuarios de Windows y Excel, también es posible abrir una conexión con el archivo de las hojas de cálculo y seleccionar columnas o tablas de alguna de las hojas que contiene. Para ello debemos utilizar odbcConnectExcel del paquete RODBC.

Más información en R Data Import/Export

Múltiples archivos de gráficos

El otro día comentaba los múltiples formatos para guardar un gráfico generado por R (ver Devices).
Por ejemplo, en el caso de pdf(), una vez abierto, todos los gráficos producidos se guardan en el mismo archivo, hasta que lo cerremos. Pero ¿como podemos guardar cada gráfico en un archivo diferente? Pues con

pdf(onefile=F)

Esto llevará a escribir diferentes archivos del tipo Rplot001.pdf, Rplot002.pdf,...

Otros parámetros controlan el nombre del archivo y los dígitos. Para ver todas las opciones leer atentamente el help(pdf). No olvidemos cerrar el dispositivo con dev.off().

Por otra parte, en Windows, una vez que tenemos un gráfico en su ventana, lo podemos guardar a través del menú de la ventana en cualquier formato o incluso en el portapapeles. Sin embargo, en Linux es posible que no tengamos ese menú (en RKWard sí). La función savePlot() soluciona este inconveniente:

savePlot("MiFigura", type="png")

Otros formatos y posibilidades se pueden consultar en la ayuda de esta función.

polygon()

Un truco para rellenar regiones a destacar en un gráfico es utilizar la función polygon().
El gráfico anterior se consigue con el siguiente código:

curve(exp,0.5,3.5,lwd=2)

t<-seq(1,3,by=0.01)
x <- c(1,t,3)
y <- c(0,exp(t),0)
polygon(x,y,density=20)

title("Exponencial entre 1 y 3")

Observemos la utilización de los vértices adecuados para reseguir la curva exponencial.
El parámetro density=20 controla la densidad de las linias (por pulgada). Tambíen es posible rellenar el polígono con un color sólido como en el siguiente ejemplo con la densidad normal:

El código para dibujarlo es:

curve(dnorm,-3,3,axes=F) # dibujamos la curva pero no los ejes
axis(1) # ahora los ejes
axis(2)

t <- seq(0,1,by=0.01)
x <- c(0,t,1)
y <- c(0,dnorm(t),0)
polygon(x,y,col="grey") # la región en gris

curve(dnorm,-3,3,lwd=2,add=T) # la curva encima
abline(h=0)
title("Probabilidad entre 0 y 1")

Devices

Normalmente en R, un gráfico nuevo sustituye al anterior en la misma ventana, si está abierta. Pero a veces nos puede interesar dibujar el gráfico en una ventana nueva, por ejemplo para comparar los dos gráficos. Para abrir una nueva ventana gráfica podemos invocar la instrucción

x11() # en Linux

windows() # en Windows

quartz() # en Mac OS

Aunque creo que x11() funciona en los tres sistemas.

Una ventana no es más que uno de los posibles dispositivos (devices) de salida para los gráficos.
Para ver los dispositivos adicionales de salida gráfica de que disponemos en un momento dado, podemos hacer

dev.list()

y para elegir uno entre ellos (activamos el tercero, si existe):

dev.set(3)

Sabremos cual es la ventana activa ya que aparecerá la palabra ACTIVE en la barra de títulos.

Además, también es posible redirigir la salida gráfica a un archivo PDF. La siguiente instrucción abre un archivo PDF en la carpeta actual de trabajo con el nombre especificado:

pdf("figura1.pdf")

Mientras esté activo, todos los gráficos que generemos se enviarán sistemáticamente a dicho archivo. Para cerrar el dispositivo activo (dev.cur()) hacemos

dev.off()

Las funciones postscript(), png(), jpeg() y bmp() son similares a pdf(), pero crean gráficos en los formatos EPS, PNG, JPEG y BMP respectivamente. Para insertar un gráfico en LaTeX se recomienda el formato EPS, mientras que en un procesador de textos como Write de OpenOffice o Word de Microsoft es mejor PNG. Recordar que hay que cerrar estos dispositivos para poder acceder al archivo correspondiente.

Box plots

Un boxplot es un gráfico robusto que permite describir la distribución de una muestra de valores numéricos y compararla con otras (en las mismas unidades).
La robustez se debe a la utilización de estadísticos de orden. En este sentido y como medida de centralidad se utiliza la mediana, en lugar de la media.

En cuanto a la caja, conviene aclarar que no son los cuartiles los que la definen sino las bisagras (hinges), inferior y superior. La bisagra inferior es la mediana de los valores situados por debajo de la mediana de la muestra. La bisagra superior es la mediana de los valores situados por encima de la mediana de la muestra. Para muestras grandes, la bisagra inferior prácticamente coincidirá con el primer cuartil y la bisagra superior con el tercer cuartil, pero no son iguales.
En el boxplot se utilizan las bisagras por definición. Los cuartiles (y otros percentiles) se calculan de forma muy diversa y no son adecuados para fijar una definición única.
Como es natural la función boxplot() de R tiene en cuenta estos detalles y es absolutamente rigurosa con la definición de Tukey.

Otro detalle es la longitud de los bigotes (whiskers). Éstos se extienden fuera de la caja hasta el valor muestral más lejano que no supere una proporción del rango intercuartílico (calculado con las bisagras). Esa proporción se controla con el parámetro range. Su valor por defecto es 1.5, fijado así para que el número de outliers en una población normal sea relativamente pequeño. En otros programas de software estadístico como SPSS, incomprensiblemente, este valor es 2.

Por último, decir que hay otro parámetro varwidth que permite controlar el ancho de las cajas. Si lo pasamos a TRUE, el ancho de las cajas en un boxplot múltiple será proporcional a la raíz cuadrada de los tamaños muestrales de cada población. Interesante.

R Graph Gallery

En la R Graph Gallery encontraréis un buen conjunto de gráficos, todos ellos con su correspondiente código y listos para ser utilizados.
En la imagen podéis ver el resultado de la función stars() aplicado a un conjunto de variables numéricas sobre la base de datos mtcars.

LaTeX y R

Si queremos elaborar un documento dinámico o programable que combine texto y resultados estadísticos, tanto numèricos como gráficos, la mejor opción es utilizar LaTeX y R.

Para quien no conozca LaTeX diré que es un sofisticado procesador de textos que se utiliza especialmente con documentos científicos. Aunque su aprendizaje no es sencillo, vale la pena dedicarle un tiempo. Cuando se domina, los otros procesadores sólo se utilizan con textos elementales.
Para aprender LaTeX se puede empezar por la web de CervanTeX y leer el manual La introducción no-tan-corta a LaTeX2e.

Pero si ya sabes un poco de LaTeX, combinarlo con R es muy fácil. La idea es escribir un archivo con extensión .Rnw con código LaTeX normal y texto y añadirle trozos de código R (chunks).

El texto normal empieza con el signo "@", mientras que el código R empieza con "<<>>="

<<Argumento1=ValorDelArgumento1, Argumento2=ValorDelArgumento2, ...>>=
Código R

@
Texto normal y código LaTeX

Una vez redactado el documento combinado, se utiliza la función Sweave() de R para procesarlo y obtener un documento LaTeX, con extensión .tex, que contiene el texto original y los resultados, cálculos y gráficos demandados por el código R insertado. Posteriormente, el archivo .tex se procesará como es habitual en LaTeX para obtener el documento definitivo: .ps, .pdf,...

La función Stangle() permite extraer todo el código R del documento combinado (los chunks) en un archivo con extensión .R.

Un sencillo manual de Sweave.
Leer más en http://www.traba.org/wikitraba/index.php/Sweave

¿En qué SO estamos?

¡Vaya tontería! Todo el mundo sabe con qué sistema operativo trabaja.
Pero resulta que si queremos escribir un programa en R que se pueda utilizar en varios sistemas operativos, entonces la pregunta es pertinente. Esto no significa que las instrucciones de R dependan del SO en el que trabajemos. Pero hay situaciones en las que es conveniente cambiar alguna cosa en función del SO, por ejemplo, para fijar la carpeta de trabajo.

El objeto version nos proporciona una lista con los datos de nuestra versión de R. En particular, el SO con el que trabajamos.

El siguiente código, fija la carpeta de trabajo en función del sistema operativo:

linuxPath <- "/home/paco/estudios/"
windowsPath <- "c:/users/paco/documents/estudios/"
estudio <- "Blog"

SO <- version[["os"]]

if (SO=="linux-gnu"){
workingDir <- file.path(linuxPath, estudio)
}else{
workingDir <- file.path(windowsPath, estudio)
}

setwd(workingDir)

Cálculo matricial

Trabajar con matrices en R es muy sencillo.
En primer lugar, para crear una matriz podemos transformar un vector:

> x <- 1:9
> X <- matrix(x, ncol=3)

Por defecto el relleno de la matriz se hace por columnas. Si queremos que sea por filas, hay que indicarlo:

> Y <- matrix(x, ncol=3, byrow=T)

En cuanto a las operaciones con matrices, la suma de dos matrices se consigue con el operador "+"

> X + Y

El producto ordinario se puede hacer con el operador "*", pero éste sirve para calcular el producto término a término. No es el producto matricial.
El producto matricial se obtiene con el operador "%*%":

> X %*% Y

Recordar que es necesario que el número de columnas de la primera matriz coincida con el número de filas de la segunda.

La función t() calcula la matriz traspuesta:

> A <- t(X) %*% X

La función diag() se puede utilizar en dos sentidos, para construir una matriz diagonal o para extraer la diagonal de una matriz cuadrada:

> diag(1:3)
> d <- diag(X)

El determinante de una matriz cuadrada se consigue con la función det(). En cuanto a la inversa de una matriz, si tiene, se calcula con la función solve():



> b <- c(1,0,2,-1,1,0,0,0,1)
> B <- matrix(b, ncol=3)
> det(B) # no es cero, luego es inversible
> solve(B)

Si lo que queremos son los valores y los vectores propios de una matriz, debemos utilizar la función eigen() que nos da una lista:

> r.list <- eigen(X)
> valor.propio1 <- r.list$values[1]
> vector.propio1 <- r.list$vectors[ ,1]

Finalmente, si lo que queremos es la g-inversa de una matriz, podemos utilizar la función ginv() del paquete MASS que calcula la g-inversa de Moore-Penrose:

> library(MASS)
> ginv(X)

Instalación del programa R

Vamos a empezar por el principio.
Se trata de descargar e instalar el programa R en nuestro ordenador. Para ello nos debemos dirigir al servidor más cercano del CRAN. El CRAN o The Comprehensive R Archive Network es un sistema mundial de servidores que permiten acceder al mismo contenido (mirrors) en todos ellos. En el caso de España es lógico acceder a http://cran.es.r-project.org, pero podemos descargar el programa R de cualquier otro.
El siguiente paso depende del sistema operativo de nuestro ordenador.


R para Windows

Si nuestro SO es Windows (XP, Vista) de 32 bits debemos descargarnos el archivo de nombre R-X.X.X-win32.exe (donde X.X.X es el número de versión, 2.9.1 por ejemplo) que encontraremos en el subdirectorio base y que podemos guardar en alguna carpeta de nuestro disco o directamente ejecutar, para una instalación inmediata.
Durante la instalación, en general, debemos aceptar todas las opciones por defecto, pero hay una pregunta clave que debemos tener en cuenta. Cuando ofrece utilizar las opciones de configuración y por defecto nos dice que no, es mejor cambiar a si. Entonces podemos elegir la opción SDI (ventanas separadas) que está por defecto. Esto es absolutamente necesario si vamos a utilizar un interfaz gráfico como Tinn-R. En otro caso, dejaremos la opción a MDI (una ventana). El resto de las preguntas las podemos pasar con sus valores por defecto.

R para Linux

En el caso que tengamos una distribución de Linux, deberemos considerar si queremos descargarnos el código fuente y compilarlo o, mucho más fácil, descargar e instalar los paquetes ya compilados de nuestra distribución de Linux. La primera opción no es difícil, pero se considera para "expertos". La explicaremos en otro escrito más adelante. Ahora nos concentraremos en la segunda opción para una distribución Ubuntu que es una de las distribuciones de Linux más populares. Otras distribuciones para las que se dispone de paquetes específicos son Debian, Redhat i Suse.

En el caso de tener una distribución Ubuntu (en mi caso Kubuntu) debemos dirigirnos a la página correspondiente
http://cran.es.r-project.org/bin/linux/ubuntu/
donde encontraremos todos los detalles. Pero en realidad nos bastará con seguir las siguientes instrucciones:

1. Añadir a la lista de repositorios la entrada:
   deb http://cran.es.r-project.org/bin/linux/ubuntu jaunty/
   
   
2. Ejecutar en una consola las instrucciones:
   
   sudo apt-get update
   sudo apt-get install r-base

Está claro que debemos apuntar al repositorio más cercano y que hay que poner la versión de Ubuntu que tengamos en nuestro ordenador (en mi caso Jaunty).
Si no añadimos este repositorio específico, también se puede instalar R con la instrucción de consola, pero instalaríamos una versión que no sería la más reciente.
Otros detalles de esta instalación los comentaremos más adelante en otro escrito.

R para Mac OS X

Para el sistema operativo de los Mac encontraremos un archivo autoinstalable del tipo R-X.X.X.dmg. La instalación es trivial.