################################################################################
### TALLER FUNDAMENTOS DE R                                                  ###
### EJERCICIO 1.1: Una primera sesion en R                                   ###
###                                                                          ###
### Center for Conservation and Sustainable Development                      ###
### Missouri Botanical Garden                                                ###
### Website: rbasicsworkshop.weebly.com                                      ###
################################################################################

## OBJETIVO:
## El propósito de este ejercicio es que los participantes del taller se 
## familiaricen con la interface de R y la forma en la que responde a la línea 
## comandos.


## PARTE 1 ##
# Aquí se introducirá de manera preliminar varios conceptos importantes que
# cubriremos con más detalle durante el resto del taller


# El elemento '<-' se utiliza para indicar una asignación. A menudo se utiliza 
# para colocar datos dentro de un objeto. Por ejemplo:
x <- 50

# En este primer comando, se asigna el valor "50" a un objeto denominado "x".

# Los objetos en R se utilizan para almacenar información. Para saber lo que 
# está almacenado en un objeto, sólo hace falta teclear el nombre del objecto:
x

# Como ya haya notado, en R líneas que comienzan con "#" no se ejecutan. Estas 
# líneas se utilizan para crear comentarios.

# R tiene objetos pre-determinados con valores de algunas constantes 
# fundamentales. Por ejemplo, para encontrar el valor de pi sólo tiene que 
# escribir:
pi

# También se puede copiar el valor de pi a otro objeto, por ejemplo:
y <- pi
y
pi

# En R, se utilizan funciones para ejecutar acciones en R, como crear gráficos y 
# hacer análisis. Por ejemplo, la función de 'rnorm' genera valores aleatorios a 
# partir de una distribución normal:
rnorm(n=50)

# Las funciones en R actúan sobre o son modificados por argumentos. Los 
# argumentos definen cómo una función trabajará. En el ejemplo arriba, la 
# función 'rnorm' es modificada por un argumento llamado "n" que tiene el valor 
# de 50. Como consecuencia, R genera 50 valores aleatorios a partir de una 
# distribución normal. Esta línea de codigo puede modificarse para solicitar 
# tantos valores como se desee:
rnorm(50)
rnorm(5)
rnorm(1)

# Los resultado de una función también pueden guardarse en un objeto:
x <- rnorm(50)

# Ahora se puede hacer cosas con los valores almacenados en 'x'. Por ejemplo, se 
# puede utilizar la función 'mean' para calcular la media de los valores de "x":
mean(x)

# Se puede calcular otros estadísticos, como la desviación estándar o el rango:
sd(x)
range(x)


# También se puede utilizar una función (sort) para cambiar el orden de los 
# valores:
sort(x)
sort(x, decreasing=TRUE)

# Tenga en cuenta que aquí, por ejemplo, la función de "sort" toma dos 
# argumentos, uno es la sequenacia de valores "x", el otro es el valor "TRUE". 
# Usted aprenderá más cerca de los argumentos pronto en el taller.

# Esta línea de codigo crea un histograma de los valores en "x":
hist(x)

# R tiene también "operadores" que realizan una multitud de acciones. Los más 
# comunes son los operadores aritméticos de suma '+', resta '-', 
# multiplicación '*', y división '/'. Por ejemplo, podemos dividir 4 por 2:
4/2

# O, podemos multiplicar cada valor de 'x' por una constante:
x*2

# También podemos escribir una sola línea de código que realiza múltiples 
# acciones y que termina guardando los resultados, por ejemplo:
y <- rnorm(50)*2

# Esto crea 50 valores aleatorios de una distribución normal, se multiplican 
# cada uno de esos valores por 2 y, finalmente, los resultados se almacenan en 
# un objeto denominado 'y'.


# También podemos crear secuencias más complicadas de acciones, por ejemplo:
y <- 0.5 + 1.5*x + rnorm(50)

# Esta línea de código: 1) crea 50 valores de una distribución normal, 
# 2) multiplica los valores de "x" por 1.5, 3) Se suman los resultados de (1) y
# (2), 4) se suma 0,5 a cada valor en el resultado de (3), y 5) se
# almacena los resultados de estos cálculos en 'y'. Para ver los valores en 'y',
# sólo se necesita escribir:
y

# Ahora usted puede utilizar los valores de los objetos 'x' y 'y' para una serie 
# de cosas. por ejemplo, para hacer un diagrama de dispersión se utiliza la 
# función "plot":
plot (x, y)
# Esto abrirá una ventana de gráficos de forma automática.

# Para encontrar la correlación
# Entre 'x' e 'y':
cor(x, y)

# Para producir un diagrama de caja:
boxplot(x,y)

# Para correr un análisis de t:
t.test(x, y)

# Para hacer una prueba de t de solo una cola:
t.test(x, y, alternative="greater")

# Nótese la diferencia en valor de p.


# Para ver los elementos que se han creado, escribir:
ls()



## PARTE 2 ##
# En esta segunda parte, se continuará jugando con diversos elementos de R.
# Sólo tiene que ejecutar el código y mirar los resultados. Escriba el código
# en la consola de R, no solo copie y peque el código:


# Para hacer una variedad de gráficas de sen(theta):
theta <- seq(0, 2*pi, length=100)
plot(theta, sin(theta))
par(new=TRUE)
plot(theta, sin(theta), type="h")
plot(theta, sin(theta), type="l")
plot(theta, sin(theta), type="s")
theta <- seq(0, 2*pi, length=10)
plot(theta, sin(theta), type="l")

# Para ver lo que significan estos comandos, escriba:
help(plot)


# Para crear secuencias repetitivas, escriba:
c(1:25)
seq(1, 25)
seq(25, 1, -1)
seq(1, 25, 2)
seq(1, 25, length=6)
seq(0, 2, 0.1)
rep(0, 25)
rep(1, 25)


# Hace un vector de enteros de 1 a 25:
n <- c(1:25)


# Guarda la raíz cuadrada de los valores en el objeto "n", y guardar resultados
# en el objeto "w"
w <- sqrt(n)


# Simula algunas variables de respuesta, y los muestra en una tabla:
r <- n + rnorm(n) * w
data.frame(n, r)

# Crea un modelo de regresión, muestra los resultados, crea un gráfico de 
# dispersión, y dibuja la línea de regresión en el gráfico:
regress.rn <- lm(r ~ n)
summary(regress.rn)
plot(n, r)
abline(regress.rn, col="red")


# Presenta los residuos y poner etiquetas en los ejes:
plot(fitted(regress.rn), resid(regress.rn), xlab="FittedValues",
  ylab="Residuals", main="Residuals vs Fitted")


# Simula 100 lanzamientos de una moneda al aire y muestra los resultados:
x <- rbinom(100,1,0.5)
x

# A continuación, se calcula el total acumulado del número de cabezas a través 
# de los experimentos y se grafica los resultaos:
c <- cumsum(x)
plot(c, type="s")


# Simula el lanzamiento de un dado 1000 veces y presenta un resumen de resultados:
fair <- sample(c(1:6), 1000, replace=TRUE)
summary(fair)


# Simula el lanzamiento de un dado sesgado 1000 veces y se presentan los 
# resultados:
biased <- sample(c(1:6), 1000, replace=TRUE, prob=c(1/12,1/12,1/12,1/4,1/4,1/4))
summary(biased)



# El siguiente set de datos salen del famoso experimento de Michelson-Morley 
# sobre la velocidad de la luz. En este set de datos hay cinco experimentos 
# (columna 'Exp'), cada uno con 20 corridas (columna 'Run'). La columna "Speed" 
# es la velocidad de la luz. Para ver una descripción de estos datos, escriba:
morley


# Los datos en las dos primeras columnas son caracteres. Esto hace que el número 
# de experimento se convierta en un factor:
morley$Expt <- factor(morley$Expt)

# Hace un diagrama de caja de la velocidad de la luz en la columna 3:
boxplot(morley[ ,3] ~ morley$Expt, main="Speed of Light Data",
  xlab="Experiment", ylab="Speed")

# Realiza un análisis de varianza para ver si se mide la velocidad son 
# significativamente diferente entre los experimentos:
anova.mm <- aov(Speed ~ Expt, data=morley)
summary(anova.mm)


# Dibuja una función cúbica:
x <- seq(-2, 2, 0.01)
plot(x, x^3-3*x, type="l")

# Dibujar una curva de campana:
curve(dnorm(x), -3, 3)

# Examina la función de masa de probabilidad de una distribución binomial:
x <- c(0:100)
prob <- dbinom(x, 100, 0.5)
plot(x, prob, type="h")


# Para trazar una curva parametrizada, se inicia con una secuencia de valores y
# luego se da valores en los ejes "y" y "x"
# valores:
angle <- seq(-pi, pi, 0.01)
x <- sin(3*angle)
y <- cos(4*angle)
plot(x, y, type="l")


# Ahora vamos a graficar curvas de nivel y una superficie. En primer lugar, 
# creamos una secuencia de valores. Esta vez especificamos el número de términos:
x <- seq(-pi, pi, len=50)
y <- x

# A continuación, definimos una función de los valores en ejes x y y para dibujar
# un mapa de contornos:
f <- outer(x, y, function(x, y) (cos(3*x) + cos(y)) / (1 + x^2 + y^2))
contour(x,y,f)

# Para dibujar un gráfico de superficie:
persp(x,y,f,col="orange")

# Para cambiar el ángulo de visión:
persp(x, y, f, col="orange", theta=-30, phi=45)