Algunas consideraciones sobre ggplot2

Antes de continuar con otros gráficos, es necesario tener en cuenta algunas consideraciones sobre el paquete ggplot2. Imaginemos que queremos estudiar un efecto muy conocido en la literatura de procesamiento numérico: el problem size effect. Este efecto muestra que somos más rápidos en resolver operaciones pequeñas (ej.: 3+5) que operaciones grandes (ej.: 22+ 7). Imaginemos que 20 participantes han realizado una tarea de sumas. Las sumas podían ser de una cifra (problem size pequeño) o de dos (problem size grande). Los resultados están en la matriz problem_size, asi que lo primero que haremos es cargar la matriz de datos. 

problem_size <- read.csv("problem_size.csv", header=T)

Una vez que hemos cargado nuestra matriz, podemos ver que en la primera columna tenemos a cada sujeto (esta columna es prácticamente irrelevante). En la segunda columna tenemos los resultados de cada sujeto para las operaciones de una cifra y en la tercera los resultados para las operaciones de dos cifras. Estamos ante un diseño intrasujeto, ya que todos los participantes pasan por todas las condiciones del experimento. Cada columna en la matriz de datos representa cada una de las condiciones (pequeña y grande) de nuestra variable independiente (problem size). Este tipo de matriz recibe el nombre de matriz de formato ancho (wide format). Un ejemplo lo podemos ver en la siguiente matriz. 

Cuando realizamos  un gráfico usando  el paquete ggplot2, tenemos que tener en cuenta que siempre representaremos la relación entre dos variables de nuestra matriz. Sin embargo, en este caso, nosotros no queremos representar la relación entre  las condiciones peque y grande, sino que queremos representar la relación entre la variable condición (peque y grande) y el tiempo empleado en resolver el problema. Por lo tanto lo primero que tendremos que hacer es modificar la matriz de tal forma que en una columna aparezca la variable condición y en una segunda columna la variable tiempo. Ya que nuestro diseño es intrasujeto, cada participante aparecerá en dos filas diferentes: una para la condición pequeña y otra para la grande. En resumen, nuestra nueva matriz tendría que ser en formato largo (long format) que es como la que se presenta en la siguiente imagen.

Para convertir nuestra matriz a formato largo, tendremos que bajar e instalar el paquete reshape.

install.packages("reshape")
library(reshape)

Volviendo a nuestra matriz problem_size, si queremos transformarla en formato largo crearemos una matriz llamada problem_sizeM y usaremos la función melt() para reesctructurar el contenido de la matriz en formato ancho problem_size. La forma general de esta función es como sigue:

DatosM <- melt(datos, id= c("variables constantes", measured = c("variables que cambian en cada columna"))

En id tendremos que especificar aquellas variables que no cambian entre columnas. En nuestro caso sería el número de sujeto, ya que esta variable es constante para cada participante. En nuestro caso tendríamos que añadir id= "sujeto". No tenemos que usar la función c() puesto que solo tenemos una variable constante. En segundo lugar, en measured tendremos que especificar las variables que varían en diferentes columnas o, dicho de otra manera, las diferentes condiciones de nuestra variables intrasujeto. En nuestro caso, tenemos la variable intrasujeto tamaño con dos niveles peque y grande. Por lo tanto, tendríamos que añadir measured = c("peque", "grande"). En resumen, la instrucción seria:

problem_sizeM <- melt(problem_size, id= "sujeto", measured = c("peque", "grande"))

De esta forma ya tendríamos nuestra matriz de datos transformada en formato largo. 

Click aquí para descargar la matriz de datos.

 

Gráficos de dispersión agrupados

Una de las variables de la matriz datos_ansiedad es género. Así que podría ser interesante ver si la ansiedad influye de manera diferente para hombres y mujeres en el examen de memoria. Para obtener el diagrama de dispersión agrupado por género, primeramente tendremos que incluir la instrucción colour= genero justo después de donde especificamos las variables que aparecerán en el eje x e y:

dispersion_gender <- ggplot(datos_ansiedad, aes(Ansiedad, Puntuacion, colour=Genero))

Ahora tan solo tendremos que añadir los puntos y la línea de regresión, para ello: 

dispersion_gender + geom_point()+geom_smooth(method="lm")

Sin embargo, si ejecutamos la anterior instrucción, nos daremos cuenta que el área sombreada aparece en gris tanto para el género masculino como para el femenino. Esto podemos cambiarlo si añadimos un estético a nuestro geom_smooth()  

dispersion_gender + geom_point()+geom_smooth(method="lm", aes(fill=Genero))

Como se puede ver, hemos añadido la instrucción fill para decir que el relleno del área sombreada tenga un color diferente para cada género.  

Click aquí para descargar el script de esta entrada.

Cambiar las propiedades físicas de un gráfico II

En la anterior entrada vimos como cambiar algunas propiedades de nuestro grafico. GGPLOT2 también nos permite cambiar las propiedades de la línea de regresión. Por ejemplo para cambiar el tamaño y el color de la línea también usamos las propiedades “size” y “color”:

dispersion + geom_point(size=3, color="red", shape=8)+geom_smooth(method="lm", size=3, color="yellow")
Si queremos eliminar el área sombreada alrededor de la recta de regresión, tendríamos que añadir se = F, que literalmente significa standard error = false.

dispersion + geom_point(size=3, color="red", shape=8)+geom_smooth(method="lm", size=3, color="yellow", se=F)
Por otro lado, también podemos cambiar las propiedades de esta área sombreada. Por ejemplo, podemos hacerla más transparente con la instrucción alpha= 0.1:

dispersion + geom_point(size=3, color="red", shape=8)+geom_smooth(method="lm", size=3, color="yellow", alpha = 0.1)
Cuanto mayor sea el valor de alpha menor será la transparencia del área sombreada. También podemos cambiar el color de la misma con la instrucción fill:

dispersion + geom_point(size=3, color="red", shape=8)+geom_smooth(method="lm", size=3, color="yellow", alpha = 0.1, fill ="green")
En este caso cambiaríamos el color a verde. Finalmente, si queremos añadir etiquetas a los diferentes ejes, lo podemos hacer con la siguiente instrucción:

dispersion + geom_point(size=3, color="red", shape=8)+geom_smooth(method="lm", size=3, color="yellow", alpha = 0.1, fill ="green") + labs(x = "Nivel de Ansiedad", y = "Puntuacion en memoria visual")
Como se puede ver, el paquete ggplot2 nos ofrece múltiples opciones para cambiar la apariencia visual de nuestro gráfico. Más adelante veremos cómo hacer que los elementos de nuestro grafico muestren diferentes propiedades físicas dependiendo de los niveles de la variable de estudio. Por ejemplo, diferentes colores para masculino y femenino.
PD: Click aqui para descargar el script de esta entrada.

Cambiar las propiedades físicas de un gráfico I

En la anterior entrada (Click aquí para descargar la matriz y aquí para descargar el script)
vimos cómo crear un gráfico de dispersión. En algunas ocasiones nos interesara cambiar algunas propiedades físicas del gráfico, como puede ser el color o el tamaño de los puntos, la forma de estos, etc. En esta entrada vamos a ver cómo cambiar algunas de estas propiedades.
Si queremos cambiar el tamaño de los puntos, lo debemos especificar dentro de la función geom_point() con la propiedad “size”:

dispersion + geom_point(size=3)+geom_smooth(method ="lm")
Si cambiamos el 3 por un 5, el tamaño de los puntos será, obviamente, mayor. Si además queremos cambiar el color de nuestros puntos, también tendremos que hacerlo dentro de la función geom_point(), pero esta vez con la propiedad “color”. El color lo podemos especificar de dos formas, o bien escribimos directamente el nombre del color en inglés y entrecomillado (geom_point(color=”red”)) o lo especificamos numéricamente hasta encontrar el color que queremos (geom_point(color=2)). La instrucción para cambiar el tamaño a 3 y el color a rojo seria como sigue:

dispersion + geom_point(size=3, color ="red")+geom_smooth(method ="lm")
Si además queremos cambiar la forma de los puntos, lo podemos hacer con la propiedad “shape”:

dispersion + geom_point(size=3, color="red", shape=8)+geom_smooth(method="lm")
Cambiando el número de la propiedad “shape” cambiaremos la forma de los puntos.

Esto es todo por hoy. En la proxima entrada veremos como cambiar otras propiedades del grafico.

PD: Click aqui para descargar el script de esta entrada.

Diagramas de dispersión

Después de haber publicado la anterior entrada, me he dado cuenta que puede ser bastante confusa. Creo que lo mejor para aprender cómo hacer un gráfico en R es haciéndolo. Vamos a empezar con un gráfico de dispersión. Este tipo de grafico nos permite ver si existe alguna relación entre dos (o más) variables. Básicamente, en un gráfico de dispersión representamos la puntuación de cada sujeto en una variable con su puntuación en la otra variable.

Vamos a imaginar que un investigador está interesado en estudiar la relación entre el nivel de ansiedad y la puntuación en una prueba de memoria. Para ello evaluó la ansiedad en 20 participantes a los que posteriormente sometió a una prueba de memoria visual. Para tener los datos, descárgalos en tu ordenador y agrégalos a tu directorio de trabajo (click para descargar la matriz). Como ya vimos antes para crear un directorio de trabajo, usamos la función setwd(). Entre paréntesis incluiremos la ruta. En mi caso sería:

setwd("D:/R")

Como ya dijimos, para hacer gráficos usaremos el paquete ggplot2. Si no lo hemos descargado, lo hacemos con la siguiente instrucción:

install.packages("ggplot2")

Después de instalar el paquete, hay que referenciarlo o lo que es lo mismo, decirle a R que lo vamos a usar. Esto lo hacemos con la siguiente instrucción:

library(ggplot2)

Lo siguiente seria cargar la matriz de datos “ansiedad.csv”. Para ello ejecutamos la siguiente instrucción:

datos_ansiedad <- read.csv("ansiedad.csv", header=T)

El objeto ansiedad es una matriz de datos formada por las siguientes variables:

• Género: sexo del participante
• Ansiedad: puntuación en la escala de ansiedad antes de realizar la prueba de memoria visual

• Puntuación: puntuación en la prueba de memoria visual

El primer paso para crear un gráfico (en este caso, un gráfico de dispersión) es definir un objeto en el que le digamos a R qué queremos graficar y como lo queremos. Por ejemplo, en nuestro caso queremos ver la relación existente entre ansiedad y memoria visual, por lo que debemos especificar en qué matriz se encuentran estas variables y el eje en el que queremos cada una de ellas. En nuestro caso, pondremos la ansiedad en el eje de abscisa (o eje x) y la puntuación en la prueba de memoria en el eje de ordenadas (o eje y):

dispersion <- ggplot(datos_ansiedad, aes (Ansiedad, Puntuacion))

Con esta instrucción hemos creado un objeto llamado dispersión basado en la matriz datos_ansiedad y hemos especificado que queremos que la variable Ansiedad aparezca en el eje x y puntación en el eje y. Sin embargo, no le hemos dicho como queremos representar esta información (de hecho, si ejecutamos dispersion no aparecerá nada). En nuestro caso queremos que la información sea representada mediante puntos, así que tendremos que ejecutar el siguiente comando:

dispersion + geom_point()
Si le echamos un vistazo rápido al gráfico, observamos que parece existir una relación negativa entre el nivel de ansiedad y la puntuación en la prueba de memoria visual: a mayor ansiedad menor nota. Los diagramas de dispersión suelen tener una línea que resume la tendencia de los datos (línea de regresión). Si queremos añadir esta línea, podemos hacerlo con la función geom_smooth():

dispersion + geom_point()+geom_smoth()
Con esta línea podemos ver más claramente que a mayor nivel de ansiedad, peor suele ser la nota en el examen de memoria visual. El área sombreada alrededor de la línea, representa el intervalo de confianza al 95% de la misma. Si queremos que la línea sea recta en vez de curva tendremos que añadir el método lm (linear model) en nuestra función geom_smooth():

dispersion + geom_point()+geom_smooth(method ="lm")
Esto es todo por hoy. Espero que esta entrada haya sido de utilidad!
Click aquí para descargar el script de esta entrada.

Introducción a los gráficos

Uno de los mayores atractivos de R es su capacidad para realizar gráficos. Sin embargo, esto no está exento de cierta complejidad. El paquete que uso para crear gráficos es el ggplot2. Así que primeramente debemos descargar el paquete si no lo hemos hecho antes:

install.packages(“ggplot2”)
Podemos decir que un gráfico en R está formado por diferentes capas. Por capa, se entiende cada elemento que conforma el gráfico. Por ejemplo, ejes de coordenadas, columnas, barras de error, leyenda, etc. Nuestra misión con un gráfico será combinar todos estos elementos en uno solo: el grafico final. Para incluir estos elementos usaremos las funciones geoms. Hay multitud de ellas, pero aquí solo veremos unas cuantas:

• geom_bar(): para crear gráficos de barras
• geom_point(): crea gráficos de puntos como diagramas de dispersión
• geom_line(): nos permite unir puntos con una línea
• geom_smoth(): crea una línea que resume la tendencia de los dato
• geom_histogram(): crea un histograma
• geom_errorbar(): crea barras de error

Por supuesto que todas estas funciones se pueden combinar para crear el grafico final. De hecho, en la mayoría de nuestras ocasiones esta será la norma (por ejemplo, cuando queremos añadir barras de error a nuestro histograma). Como veremos más de adelante, dentro del paréntesis de cada función geom tendremos que incluir los estéticos (aesthetics, en inglés). Muchos de ellos son opcionales (color, tamaño, etc.), pero determinaran como es nuestro gráfico.

Transformacion de datos II

En la anterior entrada aprendimos a realizar algunas manipulaciones a nuestra matriz de datos de cara a facilitarnos el analisis: creamos dos nuevas variables que nos indicaban los tiempos de reaccion y si la respuesta dada por el participante era correcta (click aqui para descargar la matriz de datos de la anterior entrada). Lo siguiente que podemos hacer es calcular el porcentaje de ensayos correctos. La función table() nos da el número de veces que se repite un valor de la variable (frecuencia absoluta), por lo que en nuestro caso esta función nos daría el número de ensayos correctos e incorrectos. Teniendo en cuenta que el número total de ensayos fue de 50 podemos calcular el porcentaje de ensayos correctos e incorrectos multiplicando la frecuencia absoluta por 100 y dividiéndola por 50:

table(data$ACC)*100/50

Con esta instrucción le estamos pidiendo a R que nos de la frecuencia absoluta para la variable ACC y que la multiplique por 100 y la divida por 50. Como podemos ver un 44% del total de los ensayos fueron correctos (un número relativamente bajo, pero los resultados son totalmente inventados).

 

Si seguidamente queremos analizar exclusivamente los ensayos correctos, podemos crear una matriz exclusivamente con estos ensayos. Para ello podemos usar la función subset():

RespCor <- subset(data, ACC =="correcto", select= c("Time", "ResponseTime", "Correct", "Keypress", "Condition","RTs"))

Con esta instrucción le estamos diciendo a R que cree una nueva matriz de datos. Esta nueva matriz de datos contendrá los ensayos correctos de la matriz data (data, ACC =="correcto") para las variables Time, ResponseTime, Correct, Keypress, Condition y RTs (select= c("Time", "ResponseTime", "Correct", "Keypress", "Condition","RTs")).

 

Por último, imaginemos que solo queremos los ensayos dentro de un rango de tiempo de respuesta determinado, por ejemplo, entre 700 y 1150. Esto también lo podemos hacer con la función subset():

Trimmed <- subset(RespCor, RTs>= 700 & RTs<= 1150, select= c("Time", "ResponseTime", "Correct", "Keypress", "Condition","RTs"))

Con esta instrucción le estamos indicando a R que cree una nueva matriz de datos que contenga aquellos ensayos de la matriz RespCor que contengan unos tiempos de reacción entre 700 y 1150 (RespCor, RTs>= 700 & RTs<= 1150) para las variables Time, ResponseTime, Correct, Keypress, Condition y RTs (select= c("Time", "ResponseTime", "Correct", "Keypress", "Condition","RTs")).

 

Con esta y con la anterior entrada, he intentado mostrar que en muchas ocasiones antes de realizar el análisis de datos, tendremos que limpiar un poco nuestra matriz de datos. En las próximas entradas empezaremos a realizar análisis descriptivos de nuestros datos. Click aquí para descargar el script de esta entrada.

Transformación de datos I

Aunque ya hemos visto algo de transformación de datos aquí, aquí y aquí creo que el tema es importante por lo que merece la pena ahondar un poco más. En la mayoría de las ocasiones tendremos nuestros datos en bruto, es decir, una matriz de datos con todas las veces y condiciones por las que ha pasado el sujeto. Por dicha razón, tendremos que realizar ciertas operaciones que ordenen nuestros datos.

Esta matriz de datos puede servir de ejemplo para esto anterior, así que una vez que la bajes tendrás que cargarla:

data <- read.csv ("data.csv", header= T)

Si le echamos un vistazo a la matriz vemos que está compuesta por cinco variables:

• X: número de ensayo.
• Time: el tiempo que tarda el estímulo en aparecer una vez que el ensayo se ha iniciado. Como se puede ver este tiempo es siempre el mismo.
• ResponseTime: el tiempo que tarda el participante en responder una vez que el ensayo se ha iniciado.
• Correct: tecla que el sujeto debería presionar en ese ensayo.
• Keypress: tecla que el sujeto presiona en ese ensayo.
• Condición: condición del estímulo en ese ensayo concreto.

Lo primero que podemos hacer es crear una variable con el tiempo que el participante tarda en responder una vez que el estímulo ha aparecido (tiempos de reacción). Si la variable ResponseTime es el tiempo que se tarda en responder desde que el ensayo se inicia, y la variable Time es el tiempo que tarda el estímulo en aparecer, el tiempo de reacción al estímulo será igual a la diferencia entre ResponseTime y Time. Podemos, por lo tanto, crear una nueva variable dentro de nuestra matriz de datos con los tiempos de reacción. Para ello, podemos ejecutar la siguiente instrucción:

data$RTs <- data$ResponseTime-data$Time

Es posible que queramos analizar separadamente los ensayos correctos e incorrectos. Para ello sería conveniente crear una variable que nos dijera si un ensayo concreto fue correcto. En nuestra matriz de datos tenemos la variable Correct, tecla que se tiene que presionar para que el ensayo sea correcto, y la variable Keypress, tecla que el sujeto apretó. Por lo tanto un ensayo será correcto cuando la variable Correct sea igual a la variable Keypress. Podemos crear una nueva variable que tenga esto en cuenta con la función condicional ifelse():

data$ACC<- ifelse(data$Correct==data$Keypress,"correcto","incorrecto")

Con esta instrucción le estamos diciendo a R que cree la variable ACC (del inglés accuracy) dentro de la matriz de datos data. Si el valor de la variable Correct es igual al valor de la variable Keypress, ACC será igual a “correcto”. Por el contrario, si el valor de la variable Correct es diferente al valor de la variable Keypress, ACC será igual a “incorrecto”.

 

Pues esto es todo por hoy, en la siguiente entrada seguiremos con esto un poco más. 

Instalar paquetes

R viene de serie con una serie de funciones que nos permiten realizar diferentes tareas. Sin embargo, en muchas ocasiones necesitaremos de ciertas funciones que no están incluidas y que, por tanto, tendremos que descargar e instalar. La forma más fácil de descargar e instalar estos paquetes es mediante la siguiente instrucción:

install.packages (“nombre del paquete”)

Esta función es muy intuitiva y básicamente le pide a R que instale el paquete nombre del paquete. Veámoslo con un ejemplo. Uno de los paquetes que usaremos en el futuro es ggplot2. Como tendremos oportunidad de ver, este paquete nos permite hacer gráficos realmente potentes y profesionales. Para instalarlo tendríamos que ejecutar la siguiente instrucción:

install.packages(“ggplot2”)

El nombre del paquete siempre tiene que estar entrecomillado. Ya no necesitaremos reinstalar el paquete (a no ser que cambiemos de ordenador, formateemos el equipo, etc.), sin embargo, cuando lo queramos usar tendremos que cargarlo. Esto lo hacemos con la funciona library(), y siguiendo nuestro anterior ejemplo, la instrucción seria:

library(ggplot2)
Es importante señalar que en este caso el nombre del paquete no va entrecomillado. Desconozco la razón, pero es así. Con esta simple instrucción ya podríamos usar el paquete. 

La función subset()

En la anterior entrada vimos como seleccionar partes específicas de la matriz de datos. En esta entrada vamos a ver otra forma para seleccionar los casos. Click aquí para descargar la matriz de datos que usaremos en esta entrada La función subset() nos permite seleccionar partes específicas de nuestra matriz. La forma general de esta función es como sigue:

subset(matrizdedatos, casos que queremos seleccionar, select= lista de variables)

Hay que tener en cuenta que en la parte que dice “casos que queremos seleccionar” tenemos que incluir algún operador lógico (>, <, ==, etc.)  Con un ejemplo se ve más fácil. Si queremos seleccionar las ratas que obtuvieron un tiempo menor a 22 tanto en las variables tiempo1 como tiempo2, usamos la siguiente instrucción: 

DatosMenor22<- subset(Datos,tiempo1 <22 & tiempo2 < 22, select= c("grupo", "tiempo1", "tiempo2"))

Con esta instrucción le estamos diciendo a R que cree el objeto DatosMenor22 y que dicho objeto contenga las columnas grupo, tiempo1 y tiempo2, pero exclusivamente los valores menores a 22 de las variables tiempo1 y tiempo2.

De manera similar, si queremos conocer los tiempos en la variable tiempo1 para el grupo 1 y 2 lo haríamos mediante la siguiente instrucción:

DatosG1y2T1 <- subset(Datos, grupo == "Grupo1" | grupo =="Grupo2" , select =c("grupo", "tiempo1"))

Con esta instrucción le estamos pidiendo a R que nos dé los valores en el Tiempo_1 que cumplan con la condición de que la variable grupo sea  igual a “Grupo1” o (|)  a “Grupo2. Por lo tanto, nos dará los valores tanto del Grupo1 como del Grupo2.

Pues esto es todo por hoy. Si quieres descargar el script usado en esta entrada, sólo tienes que hacer click aquí. 

Seleccionar partes específicas de la matriz

En esta entrada vamos a utilizar la matriz de datos del experimento sobre ratas que describí en esta entrada. Para descargar esta matriz haz click aquí. Una vez descargada y colocada en nuestro directorio de trabajo procedemos a cargarla:

Datos<-read.csv ("ratas.csv", header=T)

En algunas ocasiones, y por diferentes razones, queremos seleccionar alguna parte específica de nuestra matriz y guardarla en otro objeto diferente para poder trabajar con esta parte de manera más sencilla. Para seleccionar casos específicos de la matriz de datos, la instrucción general seria como sigue:

Nuevamatriz<- Matrizdedatos[filas, columnas]

Mediante esta instrucción creamos una nueva matriz (Nuevamatriz) que contiene las filas y las columnas que especifiquemos de la vieja matriz (Matrizdedatos). Imaginemos ahora que nos hemos dado cuenta que cometimos un error de medición en el tiempo1 y por lo tanto queremos seleccionar solo los casos que contienen el tiempo2 y guardarlo en una nueva matriz llamada Datos2. Para ello ejecutamos la siguiente instrucción:

Datos2 <- Datos[1:20, c(1,3)]

Con esta instrucción le estamos diciendo a R que cree un nuevo objeto llamado Datos2 que contiene las filas de la 1 a la 20 (todos los participantes) y las columnas 1 y 3 (grupo y tiempo2) de la matriz Datos. Otra forma más sencilla de hacerlo es como sigue:

Datos2 <- Datos[, c("grupo","tiempo2")]

La instrucción dos funciones hacen lo mismo, pero tienen dos diferencias importantes. Primero, en esta última matriz, no hemos especificado las filas que queremos seleccionar. Cuando no lo hacemos, R asume que queremos todas las filas. La segunda diferencia es que para especificar las columnas hemos usado la función c() con el nombre de las variables que queremos seleccionar.

Imaginemos ahora que sospechamos que en el bebedero de las ratas del grupo 5 había una  concentración de glucosa mayor que en los bebederos de otros grupos. Por lo tanto queremos mirar más detenidamente sus datos. Para ello usamos la siguiente instrucción:

Datos_Grupo5 <- Datos[Datos$grupo=="Grupo5",]
Datos_Grupo5

Con esta instrucción lo que le estamos pidiendo a R es que nos muestre todas las columnas de las filas que sean igual a Grupo5. Si ciertamente estamos seguros que el bebedero del grupo 5 tenía una dosis demasiado alta de glucosa y queremos eliminar a este grupo de  nuestra matriz, podemos hacerlo con la siguiente instrucción:

Nuevos_datos<- Datos[Datos$grupo!="Grupo5",]
Nuevos_datos

Con esta instrucción le estamos diciendo a R que cree un nuevo objeto llamado Nuevos_Datos y que del objeto Datos no seleccione ni las filas ni las columnas del grupo 5, pero si lo demás. Es decir, que almacene los datos que no sean del grupo 5.

En algunas ocasiones, es necesario realizar puntos de cortes en nuestros datos. Esto ocurre cuando no queremos valores mayores o menores a un determinado valor. Más de 22 segundos es un tiempo excesivo para recorrer el laberinto. Por dicha razón sería conveniente eliminar estos datos:

DatosMenor22 <- Nuevos_datos[Datos$tiempo1 <22,]

Con esta instrucción le estamos pidiendo a R que cree un nuevo objeto llamado  DatosMenor22 y que selecciones las filas que tengan un tiempo1 menor de 22 de todas las columnas. Sin embargo, un problema de la anterior instrucción es que solo tiene en cuenta los tiempos mayores a 22 en la variable tiempo1. Si queremos considerar los tiempos tanto de la variable tiempo1 y tiempo2 entonces tenemos que introducir la siguiente instrucción:

DatosMenor22 <- Nuevos_datos[Datos$tiempo1 <22 & Datos$tiempo2 < 22,]

El símbolo & es el que usamos para indicar a R que se tienen que dar las dos condiciones establecidas, es decir, que los tiempos tiempo1 y un tiempo2 sean  menores de 22.

Esto es todo por hoy. En la próxima entrada veremos como seleccionar partes de una matriz usando una función específica para ello. Hasta la próxima!

PD: click aquí para descargar el script de esta entrada. Recuerda hacer click en la parte superior derecha para saltar la publicidad 

Importar matrices de datos y crear un directorio de trabajo

Hemos aprendido a crear matrices de datos en R. Aunque es un procedimiento sencillo, en muchas ocasiones nos encontramos con que tenemos una matriz que ha sido creada usando otro software (Excel, SPSS, etc.). Sería muy engorroso tener que copiar los datos manualmente a R. Para evitar esto, podemos importar la matriz, es decir, que pasemos esos datos directamente a R. La instrucción que le daremos a R dependerá de la extensión de los datos que hemos guardado. Las dos mejores opciones para poder leer matrices en R es haberla guardado previamente como texto delimitado por tabulaciones (.txt en Excel y .dat en SPSS) o como texto delimitado por comas (.csv). En el primer caso, la instrucción seria como sigue:

Matriz <- read.delim(“datos.extension”, header=True)
Con esta instrucción le estamos pidiendo a R que cree un objeto llamado matriz. Esta matriz estará basada en la matriz datos.extension. En este caso, ya que la matriz ha sido guardada previamente mediante texto delimitado por tabulaciones, usamos la función read.delim() y como extensión o .txt o .dat. La última parte de la instrucción (header=True o header=T), le dice a R que la primera fila de los datos contiene el nombre de las variables. En el caso de que hayamos usado un texto delimitado por comas la función sería similar con la diferencia de que usaríamos en vez de la función read.delim(), la función read.csv().  Otra diferencia es que en este caso la extensión del archivo siempre sera .csv.

Sin embargo, es importante que la matriz que queremos cargar en R este en nuestro directorio de trabajo. Este concepto hace referencia al lugar de muestro ordenador donde R buscara los datos. Así que lo primero que deberíamos hacer cuando abrimos R es establecer nuestro directorio de trabajo. Allí mismo almacenaremos los datos que queremos cargar. Para establecer nuestro directorio ejecutamos la siguiente instrucción:

setwd(“ruta”)
Por ruta entendemos donde exactamente queremos nuestro directorio. Imaginemos que queremos establecer este directorio en la unidad D, en la carpeta R. Para ello usaríamos la siguiente instrucción:

setwd("D:/R")
Por último, si queremos comprobar cuál es nuestro directorio de trabajo, lo podemos hacer con la siguiente instrucción:

getwd()
A partir de la próxima entrada empezaremos a cargar las matrices. 

Diseños intrasujetos y mixtos

Vamos a imaginar otro experimento con un diseño un poco diferente. Imaginemos que queremos conocer la importancia de ciertas áreas cerebrales en la memoria espacial. Para ello tenemos cuatro grupos de ratas a las que se les ha diseccionado una parte diferente del cerebro a cada grupo (Grupo1, Grupo2, Grupo3 y Grupo4). Además tenemos un quinto grupo a la que no se le realizo ninguna disección (Grupo5). El experimento consistía en tres diferentes fases. Se cronometra el tiempo (en segudos) que una rata tarda en recorrer un laberinto (Tiempo_1). Las ratas del grupo 1, 2, 3 y 4 fueron sometidas cirugía de disección, mientras que a las del grupo 5 se les sometió  a una pequeña cirugía, pero sin disección. Se volvía a cronometrar el tiempo que las ratas tardaban en cruzar el laberinto (Tiempo_2). En la siguiente tabla se puede ver la matriz de datos:

El diseño de este experimento es un poco diferente al anterior. Tenemos la variable intersujetos grupo, la cual toma cinco valores diferentes (los diferentes grupos). Por otro lado, tenemos la variable tiempo que es una variable intrasujetos (todos los sujetos pasan por las diferentes condiciones de esta variable) con dos niveles: Tiempo_1 y Tiempo_2. Este tipo de diseño recibe el nombre de diseño mixto. Vamos a introducir los datos en R.

Tenemos la variable cualitativa nominal Grupo. Como hemos visto anteriormente, introducirla en R es sencillo, pero tenemos que tener en cuenta que hay 4 ratas en cada grupo, por lo que la mejor opción es usar la función rep(): 

Grupo <- c(rep(1,4), rep(2,4), rep(3,4), rep(4,4), rep(5,4))

Una vez que hemos introducido la variable Grupo, tenemos que factorizarla. Como ya vimos anteriormente, la instrucción es la siguiente

Grupo <- factor(Grupo, levels = c(1,2,3,4,5), labels = c("Grupo1", "Grupo2", "Grupo3", "Grupo4", "Grupo5"))

Como en el caso anterior mediante la instrucción c(1,2,3,4,5) le hemos dicho a R los niveles o valores que tiene nuestra variable grupo. Un pequeño truco para simplificar es usar la siguiente instrucción c(1:5) que literalmente significa todos los valores entre 1 y 5. De esta forma, la anterior instrucción quedaría simplificada como sigue:

Grupo <- factor(Grupo, levels = c(1:5), labels = c("Grupo1", "Grupo2", "Grupo3", "Grupo4", "Grupo5"))

Ya hemos introducido la variable grupo. La siguiente variable es la variable Tiempo. Esta variable es numérica y tiene dos niveles: Tiempo_1 y Tiempo_2. Sin embargo, a diferencia de la variable Grupo, estamos ante una variable intrasujeto, ya que todos los participantes pasan por todas las condiciones de esta variable. Esto anterior lo tenemos que tener en cuenta en R: si miras la tabla anterior, en una variable intersujeto los diferentes niveles son colocados según las filas de la tabla, sin embargo, los diferentes niveles de una variable intrasujetos son colocados en diferentes columnas. De esta manera, nos aseguramos que todos los sujetos pasan por cada una de las condiciones de esta variable. Para realizar esto anterior en R, tendríamos que crear dos diferentes objetos en R: una con cada condición de la variable Tiempo. Así para Tiempo_1 seria:

Tiempo_1 <- c(20,22,19,22,25,20,23,22,19,25,22,24,22,23,21,20,24,22,23,18)

Y para tiempo tiempo_2:

Tiempo_2 <-c(18,18,20,19,22,13,12,15,17,16,19,20,17,12,19,13,14,12,11,9)

Una vez hecho esto, pasamos a crear nuestra matriz de datos

Datos <- data.frame(Grupo, Tiempo_1, Tiempo_2)

Un pequeño apunte: en este caso, y a diferencia de lo que vimos en la entrada anterior, hemos factorizado la variable grupo antes de introducirla en la matriz de datos. Esto es todo por hoy. 

PD: Si quieres descargar el script que hemos usado, haz click aquí 

Factorizando variables

En nuestra anterior entrada vimos cómo crear una matriz de datos que siga la lógica de un diseño intersujetos. En este tipo de diseño, cada sujeto sólo participa en una de las condiciones. Si recordamos el ejemplo, queríamos comprobar si la hormona oxitocina mejoraba el reconocimiento de rostros. Para ello teníamos un grupo de 10 hombres y 10 mujeres que fueron expuestos o bien con un tratamiento placebo (condición control) o bien con un tratamiento de  oxitocina (condición experimental). Cada participante recibe exclusivamente uno de los tratamientos (click aquí para descargar el script de la anterior entrada). 

Una vez que cargues el script, podrás ver que tenemos dos variables nominales (tratamiento y sexo). Estas variables que representan categorías diferentes entre sí, pero carecen de significado numérico. Dicho de otro modo, los números asignados a cada uno de los componentes de una variable nominal, simplemente representan diferentes grupos. En el caso de la variable sexo, el uno representa al grupo masculino y el dos al grupo femenino. Sin embargo, a no ser que especifiquemos lo contrario, R tratará a las variables como numéricas. Por dicha razón, tenemos que factorizarla, es decir, indicarle a R que esta variable es nominal y que, por lo tanto, estos números solo representan categorías. La instrucción general que le tenemos que dar a R es la siguiente:

factor(variable, levels =c(a,b,c…), labels=c("label1", "label2"…))

Veamos paso a paso esta instrucción. Lo primero es indicarle a R qué variable queremos factorizar. En nuestro caso es la variable Sexo de la matriz de datos Datos, por lo que la instrucción seria factor(Datos$Sexo). Sin embargo, también tenemos que indicarle a R cuales son los niveles de nuestra variable. En este caso, tenemos 1 y 2, por lo que sería levels=  c(1,2). Por último, le añadimos las etiquetas correspondientes a 1 y 2, en este caso masculino y femenino, respectivamente: labels=c("Masculino", "Femenino"). Si unimos la anterior instrucción y la asignamos a la variable Sexo de la matriz Data, seria:

Datos$Sexo <- factor(Datos$Sexo, levels = c(1,2), labels= c("Masculino", "Femenino"))

Al igual que el objeto Sexo, también tenemos que factorizar la variable Tratamiento. La instrucción seria como sigue:

Datos$Tratamiento <-factor(Datos$Tratamiento, levels = c(1,2), labels=c("Oxitocina", "Placebo"))

Y de esta forma ya sabe R que estas dos variables son nominales. Hasta la próxima!

PD: click aquí para descargar el script de esta entrada. Recuerda hacer click en la esquina superior derecha para saltar la publicidad. 

 

Diseños intersujetos

Vamos a ver ejemplos un poco más complejos que los vistos hasta ahora. Imaginemos que queremos comprobar si la Oxitocina (una hormona) tiene algún efecto en el reconocimiento de caras. Para ello hemos elaborado un experimento con un diseño intersujeto (los sujetos solo participan en una condición experimental) en el que han participado 10 hombres y 10 mujeres. De cada grupo, a 5 se les administro oxitocina intranasal mientras otros recibieron un placebo. Todos los participantes cumplimentaron un test que evaluaba su capacidad para reconocer caras. La puntuación máxima que se puede obtener en este test es de 20. En la siguiente tabla se pueden ver las puntuaciones de cada grupo.

Vamos a introducir estos datos en R. La primera columna hace referencia al número de sujeto. Cuando creemos la matriz, R dará estos números automáticamente, por lo que no hace falta que los introduzcamos nosotros. La siguiente variable es Sexo. La mitad de nuestros sujetos son de género masculino y la otra mitad de género femenino. Esta variable es de tipo cualitativa nominal, es decir, representa categorías que son diferentes entre sí,  pero tales categorías no son medibles. Tan solo podemos decir que son diferentes entre sí. Aunque estas variables no sean medibles, si se representan con números. Sin embargo estos números tienen un carácter totalmente arbitrario y sólo indican al grupo al que pertenece un determinado sujeto. Imaginemos que asignamos el número 1 para el género masculino y el número 2 para el femenino. Podemos crear el objeto Sexo con la variable c():

Sexo <- c(1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2)

Es muy tedioso tener que repetir tantas veces los mismos números. En situaciones como esta podemos usar la función rep(x,y), siendo x lo que queremos repetir e y el número de veces  que queremos que se repita. En el caso que nos ocupa, la instrucción seria como sigue:

Sexo <- c(rep(1,10), rep(2,10))

Con esta instrucción le estamos pidiendo a R que cree el objeto Sexo usando la función c(). Dentro de esta función, usamos la función rep() dos veces: la primera repite el numero 1 un total de diez veces, y la segunda repite el numero 2 otras diez veces. 

La siguiente variable es Tratamiento que, al igual que la variable Sexo, es también nominal. Imaginemos que le asignamos el valor 1 al tratamiento con oxitocina y 2 al placebo. Como se puede ver en la tabla, los primeros cinco participantes recibieron oxitocina, los siguientes 5 recibieron placebo, los siguientes 5 oxitocina y los últimos 5 placebo. Este orden tenemos que respetarlo al incluir nuestra nueva variable. La instrucción seria como sigue:

Tratamiento <-c(rep(1,5), rep(2,5),rep(1,5),rep(2,5))

Con esta instrucción le estamos diciendo a R que cree el objeto Tratamiento con la función c() y que los primeros cinco elementos de este objeto sean un 1, los segundos cinco sean un 2, los siguientes cinco elementos un 1 y, finalmente, los cinco últimos elementos un 2. De esta forma nos aseguramos que el orden de los elementos de nuestro objeto es igual que en la tabla. 

Ahora solo nos faltaría por incluir la variable puntuación. Como hemos hecho en otras ocasiones, usaremos la función c():

Puntuacion <-c(18,18,20,19,20,13,12,15,17,16,19,20,17,12,19,13,14,12,11,9)

Una vez que hemos introducido las variables, podemos unirlas en una matriz de datos:

Datos <-data.frame (Sexo, Tratamiento, Puntuacion)
En la siguiente entrada veremos cómo decirle a R que considere nuestras variables nominales como tales. Hasta la próxima!

PD: click aquí para descargar el script de esta entrada. Recuerda hacer click en la esquina superior derecha para saltar la publicidad.

Un pequeño truco: la función attach ()

En esta entrada voy a tratar de explicar una función que, aunque reconozco que no uso mucho, es muy útil. En la anterior entrada vimos una matriz que contenía los datos correspondientes  a los ingresos económicos de cinco amigos en el 2013(accede al script de la anterior entrada haciendo click aquí). Si quisiéramos acceder a la variable tendríamos que teclear lo siguiente:

Amigos$Ingresos2013
Es decir, primero tenemos que escribir el nombre de la matriz de datos seguido de $ y del nombre de la variable. Cuando tenemos nombres demasiado largos esto puede resultar un poco tedioso. Para facilitarnos el trabajo podemos usar la función attach (). Esta función la tendremos que usar sobre una matriz de datos y hace que podamos acceder directamente a  las diferentes  variables que componen la matriz de datos. Es decir, si ejecutamos esta función sobre nuestra matriz de datos amigos:

attach(Amigos)
tan solo tendríamos que nombrar la variable a la que queremos acceder sin necesidad de nombrar la matriz de datos de la que proviene:
 
Ingresos2013
Si quisiéramos calcular la diferencia entre los sueldos de 2013 y 2010, ahora lo haríamos simplemente con la siguiente instrucción:

Ingresos2013-Ingresos2013
Esto nos facilitara el trabajo especialmente cuando tenemos variables con nombres muy largos. En la próxima entrada, veremos matrices un poco más complejas y nos iremos metiendo un poco más a fondo con los diferentes diseños de investigación. Hasta la próxima!

PD: Si quieres descargar el script usado en esta entrada, haz click aquí. Recuerda hacer click en la esquina superior derecha para evitar la publicidad.

Algunas operaciones sencillas con matrices de datos

En la anterior entrada vimos cómo crear una matriz de datos a partir de varias variables. Si no tienes esa matriz de datos haz click aquí para descargar el script, puesto que vamos a seguir usándola en esta entrada. Imaginemos ahora que queremos añadir a nuestra matriz de datos los ingresos mensuales de nuestros amigos en los años 2013 y 2010. Empecemos con los ingresos en el 2013. Imaginemos que estos son 1500, 1800, 1300, 1000, 1200, respectivamente. Para añadir este nuevo objeto a nuestra matriz usaremos la función c() de la siguiente forma:

Amigos$Ingresos2013 <- c(1500, 1800, 1300, 1000, 1200)

De la misma manera, si los ingresos de nuestros amigos  en 2010 fueron 1100, 1500, 900, 750, 900, respectivamente:

Amigos$Ingresos2010 <- c(1100, 1500, 900, 750, 900)

Con las anteriores funciones le estamos pidiendo a R que cree dos objetos dentro de la matriz de datos amigos. Si queremos ver cómo nos ha quedado nuestra matriz de datos, tan solo tendremos que escribir el nombre de la misma (Amigos). Si tan solo queremos ver los objetos que tiene nuestra matriz, podemos hacerlo mediante la siguiente instrucción:

names(Amigos)

Podemos hacer algunas operaciones aritméticas entre los objetos que forman parte de la matriz y guardarlas dentro la misma matriz. Por ejemplo, tenemos los sueldos mensuales de nuestros amigos, pero no sus sueldos anuales. Ya que un año tiene 12 meses, si multiplicamos el sueldo mensual por 12 obtendremos el sueldo anual. Esto en R lo podemos hacer de la siguiente manera:

Amigos$IngresosAnuales2013 <- Amigos$Ingresos2013*12
Amigos$IngresosAnuales2010 <- Amigos$Ingresos2010*12

Con estas dos instrucciones, hemos creado dos nuevas variables dentro de nuestra matriz de datos: IngresosAnuales2013 e IngresosAnuales2010. Estas dos variables se obtienen multiplicando por 12 los ingresos mensuales de 2013 y 2010, respectivamente. 

Imaginemos ahora que queremos saber si el sueldo de nuestros amigos en este año es mayor que el suelo de 2010, además queremos guardar la diferencia entre ambos sueldos en una nuevo objeto llamado DifSueldos. Para ellos escribimos la siguiente instrucción:

Amigos$DifSueldos <- Amigos$Ingresos2013-Amigos$Ingresos2010

Con esta instrucción, hemos creado el objeto DifSuelods dentro de nuestra matriz de datos. Dicho objeto es igual a la diferencia entre los objetos Ingresos2013 e Ingresos2010. En resumen, es posible crear nuevos objetos a partir de otros ya existentes. Para ello usaremos los diferentes operadores: + para la suma, - para la resta, * para la multiplicación y / para la división. Más adelante volveremos sobre este tema.

PD: Puedes descargar el script que hemos usado en esta entrada haciendo click aquí. Recuerda hacer click en la esquina superior derecha para evitar la publicidad 

Matrices de datos

En la anterior entrada creamos dos objetos diferentes: nombreamigos y edad (click aquí para descargar el script de la anterior entrada). Aunque estos objetos son independientes, están relacionados en el sentido de que a cada uno de los elementos de la nombreamigos (Jesus, Pedro, Pepe, Paco y Luis) les corresponde una edad determinada (35, 36, 33, 27 y 29, respectivamente). Para trabajar mejor con estos datos, lo ideal sería tener combinados estos dos objetos en uno solo que contendría una columna que se llamaría Nombres (con los nombres de nuestros amigos) y otra columna con la variable edad. Es lo que se conoce como matriz de datos. Si queremos combinar estos dos objetos tecleamos lo siguiente: 

Amigos <- data.frame(NombreAmigos, Años)

Con esta instrucción estamos creando un nuevo objeto llamado amigos mediante la función data.frame(). Primeramente, se crea un objeto llamado Amigos (ojo con la mayúscula!) que contiene las variables NombreAmigos y Años en ese mismo orden. Si quisiéramos cambiar el nombre de los objetos que aparecen en la matriz de datos por otros nombres diferentes, lo haríamos con la siguiente instrucción: 

Amigos <- data.frame(Nombre=NombreAmigos, Edad=Años)

Es decir, le estamos pidiendo a R que cree una matriz de datos igual que la anterior, pero con la diferencia de que los objetos NombreAmigos y Años aparecerán en nuestra matriz como Nombre y Edad, respectivamente. Si queremos ver, por ejemplo, el contenido del objeto Nombre de nuestra matriz tecleamos lo siguiente: 

Amigos$Nombre

Lo mismo es aplicable para el objeto Edad: 

Amigos$Edad

En definitiva, para ver el contenido de uno de los objetos de nuestra matriz de datos tenemos que teclear el nombre de la matriz seguida de $ y del nombre del objeto. 

En la siguiente entrada veremos como incluir más variables en nuestra matriz de datos y cómo realizar operaciones sencillas entre las diferentes variables. Nos vemos! 

PD: Si quieres descargar el scrip usado en esta entrada, haz click aquí. Recuerda hacer click en la esquina superior derecha para evitar la publicidad.

Creando objetos en R

R, al igual que otros lenguajes de programación, funciona mediante objetos. Los objetos son estructuras sobre las que R puede realizar diferentes tareas. Una variable es un tipo de objeto que utilizamos para guardar datos como, por ejemplo, nombre, edad, número de hijos, etc. Imaginemos que quiero coger a 5 amigos de Facebook e introducir sus datos en R. Lo primero podría ser el nombre. Para ello, tecleamos lo siguiente:

NombreAmigos <- c("Jesus", "Manolo", "Pedro", "Pepe", "Paco")

Una vez que ejecutemos el programa (seleccionando el texto y presionando CTRL + R o haciendo click en run), el objeto NombreAmigos habrá sido creado. Para crear este objeto hemos usado la función concatenar c(), que nos permite agrupar elementos (los diferentes nombres de nuestros Amigos, en este caso) en un solo objeto llamado NombreAmigos. Si escribimos ahora NombreAmigos y ejecutamos la instrucción, aparecerá en la pantalla el contenido de nuestro objeto, en este caso: “Jesus” “Manolo” “Pedro” “Pepe” “Paco”. Por el contrario si escribimos nombreamigos (en minúscula), obtendremos un error, ya que R es sensible a las mayúsculas y minúsculas.

Imaginemos ahora que Manolo se quita de Facebook y que Luis, otro amigo, se hace una cuenta. Si queremos quitar a Manolo de nuestro objeto NombreAmigos, tecleamos lo siguiente:

NombreAmigos<- NombreAmigos[NombreAmigos != "Manolo"]

Con esta instrucción lo que estamos haciendo es reescribir el objeto NombreAmigos usando el objeto NombreAmigos creado en primera estancia, pero eliminando (!=) a Manolo, o dicho de otro modo, devolviéndonos aquellso componentes que no sean igual (!=) a Manolo. Si escribimos NombreAmigos, veremos que Manolo ha desaparecido de la lista. Si queremos añadir a nuestro nuevo contacto Luis, tecleamos lo siguiente:

NombreAmigos <- c(NombreAmigos, "Luis")

Con esta instrucción, le estamos pidiendo a R que reescriba el objeto NombreAmigos, concatenando el anterior NombreAmigos (a la que ya se había eliminado a Manolo) y añadiéndole Luis. Si escribimos NombreAmigos y presionamos enter, nos aparecerá lo siguiente: "Jesus" "Pedro" "Pepe"  "Paco"  "Luis".

Vamos a crear ahora otro objeto que contenga la edad de cada uno de nuestros amigos de Facebook. Imaginemos que la edad de nuestros amigos Jesús, Pedro, Pepe, Paco y Luis es 35, 36, 33, 27 y 29, respectivamente. Para crear este nuevo objeto, tenemos que ejecutar la siguiente instrucción.

Años <- c(35, 36, 33, 27, 29)

El script con todas las instrucciones que se han visto en esta entrada, puedes descargarlo aqui. Para abrirlo solo tendrás que presionar File->open file y sólo tendrás que buscar el archivo en tu ordenador.

Hasta pronto!

Un vistazo rápido a Rstudio

La primera vez que ejecutamos Rstudio veremos algo así:

Aunque reconozco que no se ve excesivamente bien, creo que es suficiente para hacernos una idea de la estructura. Lo más importante de todo es la consola, que es la ventana situada a la izquierda. En dicha ventana, introduciremos el código de programación. Más adelante veremos para que sirven el resto de ventanas, pero nos daremos cuenta que son bastantes intuitivas. 

Vamos a realizar un pequeño ejercicio. Escribamos en la consola el siguiente código:

print("Hola Mundo!")
Si pulsamos la tecla "enter", veremos que R nos devuelve la frase "hola mundo!". Enhorabuena, has ejecutado tu primer programa en R. Básicamente, le hemos dicho a R que, mediante la función print(), escriba la frase "hola mundo!" Para usar esta función, es importante que la frase que queramos que aparezca esté entrecomilladas). Un poco más adelante explicaremos qué es una función. 

Aunque podemos realizar cualquier tipo de programa mediante la consola, la tarea de programación se facilita si usamos lo que se conocen como scripts. Dicho de forma sencilla, los scripts son archivos de texto en los que podemos escribir líneas de código para poder ejecutarlas posteriormente. Una ventaja de este tipo de archivos es que nos permite o bien ejectuar bloques de instrucciones o bien ejecutarlos individualmente. Vamos a verlo mediante un ejemplo. Primeramente abriremos un script (file-> New file ->R Script). Una vez abierto el script, tecleamos lo siguiente:

print("Hola Mundo!")
print("Adiós Mundo!")
Para ejecutar estas dos instrucciones tenemos dos opciones. Podemos ejecutar cada instrucción de manera separada,  para lo que colocamos el cursor del ratón en la instrucción  que queramos ejecutar y pulsamos Ctrl + r (o en la parte superior izquierda de nuestro script hacemos click en "run"). Por otro lado, podemos ejecutar las dos instrucciones a la vez seleccionando con el ratón el texto que queremos ejecutar y presionando Ctrl + r (o en la parte superior izquierda de nuestro script hacemos click en "run").

Otra de las ventajas obvias de usar scripts es que se pueden guardar fácilmente como archivos de texto, pudiéndolos cargar cuando queramos. Para ello tecleamos Ctrl + s, y especificamos la carpeta destino en la que guardaremos el script.

Hasta la próxima!

Instalando R

Si aún no tienes R instalado en tu ordenador, ha llegado la hora de hacerlo.  Podemos instalar el propio programa R haciendo click aquí y seleccionando la versión que necesitemos según las características de nuestro equipo. Con esto obtendríamos la versión más básica de R, el propio lenguaje de programación, y ya con esto podríamos empezar a realizar diferentes operaciones con R.

Sin embargo, mi recomendación es instalar Rstudio. Este software, que lógicamente es totalmente compatible con R, es lo que se denomina una IDE (del inglés, Integrated Development Environment). Dicho de manera sencilla, una IDE es un entorno que nos facilita un poco el trabajo con R,  ofreciéndonos características como autocompletar texto, cambiar el color de la fuente, etc. Para instalar Rstudio es necesario que primero instalemos R. Una vez realizada la instalación, basta con hacer click aquí y seleccionar la versión que precisemos según las características de nuestro equipo. 

En la siguiente entrada ya empezaremos a trabajar con R. Nos vemos! 

¿Qué es R?

Antes que nada quiero darte la bienvenida a este blog, que trata sobre el análisis estadístico usando R. Si has llegado aquí de manera casual igual te estás preguntando qué es R: Dicho de una manera rápida R es un software que nos permite analizar y representar gráficamente nuestros datos. Bajo mi opinión, las dos características más importantes de R son:

1. Es totalmente gratuito. Un programa con la potencia para el análisis de datos que tiene R puede llegar a costar en el mercado varios miles de euros. R lo podemos descargar e instalar gratuitamente en nuestro ordenador simplemente haciendo click aquí (Click en la esquina superior derecha para saltar la publicidad).

2. Es muy versátil. A diferencia de otros programas estadísticos, R nos permite hacer cualquier tipo de análisis. Una vez que hemos instalado R, ya podemos realizar análisis de datos más o menos complejos. Como veremos,  R funciona mediante funciones. Una función es simplemente una instrucción de lo que queremos hacer. Por ejemplo, si queremos calcular la media de varios valores, usaremos la función mean() . En el caso que necesitemos una función concreta que no está incluida en el programa, podremos descargar lo que se llaman “paquetes” que sí la contengan. Y si no existe tal paquete, podremos crear nosotros mismo la función.  Esto hace que en R podamos realizar cualquier tipo de operación sobre nuestros datos.

Uno de los problemas de R es que no es muy atractivo visualmente. A diferencia de otros softwares de análisis estadísticos en los que para realizar una determinada función solo tenemos que clickear en diferentes ventanas o cuadro de diálogos, en R tendremos que escribir en código de programación. Aprender este código puede convertirse en una tarea bastante frustrante. La idea de este blog es hacer este camino un poco más fácil. Cada semana intentare publicar una nueva entrada en la que explicare como realizar diferentes análisis usando R, así como algunas notas sobre estadística. Espero que este blog te sea muy útil.

Nos vemos en la siguiente entrada!