# ROGER GUEVARA (roger.guevara@inecol.edu.mx)
# INSTITUTO DE ECOLOGIA A.C
# RED DE BIOLOGÍA EVOLUTIVA
# ESTADISTICA COMPUTACIONAL EN R
# INTRODUCCION ------------------------------
# Uso básico de R -------------------------------
# R está compuesto básicamente de tres ventanas. El script o código es en
# donde se escriben todas las instrucciones, la receta. Es sin duda la
# ventana mas importante ya que una vez que se ha logrado crear un código
# este se guarda y en cualquier momento y en cualquier ordenador se puede
# ejecutar este mismo código y obtener el mismo resultado que logró el
# autor del código.
# La segunda ventana es la consola, en esta ventana aparecen los
# resultados al indicarle a R que procese una parte o todo el código
# existente. Para ejecutar un código, con el cursor en el script,se debe
# presionar CTRL & ENTER al mismo tiempo (usando Rstudio como editor o el
# editor original de R en Mac Os X). En el editor nativo de Windows se
# utiliza CTRL & R. En lo sucesivo se asume que todos están usando
# Rstudio.
# Para indicarle R que procese una línea de código basta con colocar el
# cursor sobre la linea deseada y presionar CTRL & ENTER, sin importar si
# el cursos esta al inicio, al final o en cualquier otra posición dentro
# de la linea de interés. Puedes probar con este texto colocando el curso
# en cualquier posición e indicándole a R que lo procese. Al hacerlo
# notarás que el mismo texto que se presenta aquí aparecerá en la consola.
# Como este texto está precedido de un símbolo de # R entiende que todo
# este texto es un comentario por lo cual al procesarlo simplemente
# muestra el texto lo que nos indica que si se realizó la acción deseada.
# La tercera ventana en R es aquella en la que se recrean los gráficos,
# tanto aquellos que pueden servir para explorar los datos y supuestos de
# los modelos estadísticos empleados como los gráficos de alta calidad
# adecuados para cualquier publicación/presentación. Hagamos un gráfico
# sencillo.
plot(1, 2) #CTRL & ENTER
# Esta linea de código recrea gráfico con un solo punto en las coordenadas
# X = 1 / Y = 2. Por el momento no es un gráfico muy sofisticado, pero
# solo tenga en mente que cualquier componente del gráfico se puede
# modificar en tamaño, color, posición y orientación. También cualquier
# adición que se requiera es posible, cualquier acomodo de diversos
# paneles, etc. Mas adelante regresaremos a los gráficos y aprenderemos a
# editarlos.
# Operaciones básicas ------------------------
3 #CTRL & ENTER
## [1] 3
# Observe como en la consola a diferencia de los códigos que recién hemos
# ejecutado, ahora aparece el 'eco' del código (en este documento no
# aparecen los ecos, pero al ejecutar estos códigos en Rstudio si
# aparecerán), incluyendo el comentario, y enseguida aparece EL RESULTADO,
# en este caso simplemente el número tres, el cual R reconoce como un
# número y como tal lo despliega. El número en corchetes que precede a
# este resultado es una referencia de posición. En este caso nos indica
# que el resultado, el número tres, se encuentra en la posición 1 ([1]).
# Ahora hagamos algo ligeramente mas elaborado
3 + 8 #CTRL & ENTER
## [1] 11
# Nuevamente oberve que se produce el 'eco' de la orden dada y el
# resultado, 11, en la posición [1]. Los espacios entre los números y el
# operador matemático de suma son opcionales. Aquí hay mas operaciones
# básicas
3 - 8 #CTRL & ENTER
## [1] -5
3 * 8 #CTRL & ENTER
## [1] 24
3/8 #CTRL & ENTER
## [1] 0.375
3^8 #CTRL & ENTER, tres elevado a la 8va potencia
## [1] 6561
## Además de las operaciones básicas existe las funciones para aquellas
## operaciones que no se pueden indicar claramente con un símbolo
## matemático, por ejemplo
sqrt(9) #CTRL & ENTER, raíz cuadrada
## [1] 3
9^(1/2)
## [1] 3
exp(1) #CTRL & ENTER, exponencial, 2.718282 elevado a la potencia indicada en el paréntesis
## [1] 2.718
log(2.718282) #CTRL & ENTER, logaritmo natural o neperiano
## [1] 1
log(100, base = 10) #CTRL & ENTER, logaritmo base 10
## [1] 2
log(100, base = 2.5) #CTRL & ENTER, logaritmo en base 2.5.
## [1] 5.026
# De hecho se puede calcular el logaritmo en cualquier base que se les
# ocurra
# Otras funciones comunes son:
cos(0.5) #CTRL & ENTER, coseno
## [1] 0.8776
sin(0.5) #CTRL & ENTER, seno
## [1] 0.4794
acos(0.5) #CTRL & ENTER, Arco coseno
## [1] 1.047
asin(0.5) #CTRL & ENTER, Arco seno
## [1] 0.5236
tan(0.5) #CTRL & ENTER, tangente
## [1] 0.5463
atan(0.5) #CTRL & ENTER, arco tangente
## [1] 0.4636
factorial(5) #CTRL & ENTER, factoriales
## [1] 120
# Obviamente se pueden elaborar calculas anidados, es decir operaciones de
# cuyos resultado se calcule otra operación de forma directa sin mostrar
# los resultados parciales
(4 + 8)/asin(0.3) #CTRL & ENTER
## [1] 39.38
((4 + 8)/asin(0.3)) * factorial(3) #CTRL & ENTER
## [1] 236.3
# De esta forma ya estamos utilizando R como una gran calculadora, de la
# misma forma en como muchas veces utilizan las hojas de cálculo. Sin
# embargo, como ya se han de imaginar R es mucho mas que esto. R es un
# lenguaje estadístico orientado a objetos, lo cual quiere decir que las
# variables que se crean (los objetos) tienen propiedades intrínsecas al
# tipo de objeto que este sea. El tipo de objeto mas sencillo es quizá un
# vector (numérico) que puede tener cualquier número de elementos,
# incluyendo cero elementos es decir un vector vacío.
# Para crear un objeto debemos 1) decidir un nombre con el cual haremos
# referencia a él. 2) incluir el (los) símbolo (s) de asignación (<-) que
# representa una flecha cuya punta está dirigida al nombre del objeto y el
# tallo a el valor o valores que se almacenarán en dicho objeto. Veamos
# unos ejemplos, trataremos de usar solo mayúsculas para los nombres de
# los objetos para diferenciarlos fácilmente de las funciones las cuales
# en su gran mayoría están escritas en letras minúsculas. La regla de las
# mayúsculas en los nombres de los objetos solo la usaremos como
# herramienta didáctica, y la podrán ir abandonando conforme se sienta mas
# cómodos con el uso del lenguaje R, y sobre todo conforme vayan
# memorizando las funciones.
# Las únicas reglas inviolables para nombrar objetos son, a) Solo se
# pueden usar caracteres alfa-numéricos (letras y números), punto y guión
# bajo. b) El nombre de un objeto nunca puede empezar con un número, punto
# o guión bajo. En otras palabras siempre deben comenzar con una letra. c)
# No se permiten espacios, se pueden usar puntos o guión bajo para dar el
# aspecto de espacios si se desea.
# Ahora si veamos algunos ejemplos
A <- 3 #CTRL & ENTER
# Esto crea un objeto llamado A que contiene el número tres. Observe que
# al ejecutar este código en la consola únicamente aparece el 'eco' de la
# orden dada, y no aparece ningún resultado ya que este fue almacenado en
# el nombre del objeto.
A <- 8 #CTRL & ENTER Si creamos otro objeto con el mismo nombre se reemplaza al primero
A <- 3 #CTRL & ENTER, Volvemos a nuestro objeto A que contiene el valor 3 volviéndolo a crear
# Ahora podemos usar el nombre del objeto para recuperar el resultado
A #CTRL & ENTER
## [1] 3
# Si aparece el mensaje << Error: object 'A' not found >> es que no
# ejecutó la linea de código precedente y en consecuencia el objeto A no
# existe, y es eso mismo lo que R nos indica.
# Note que al correr esta línea de código en la consola aparece el 'eco'
# de la orden, y enseguida el resultado de la misma, que en este caso es
# mostrar lo que el objeto A contiene, el número tres.
# Con la función << class() >> se puede saber que clase de objeto tenemos,
# en este caso A es un objeto numérico, es decir que únicamente puede
# contener números.
class(A)
## [1] "numeric"
# Ahora, los objetos numéricos pueden ser utilizados para realizar
# cualquier tipo de operación
A + A #CTRL & ENTER
## [1] 6
A - A #CTRL & ENTER
## [1] 0
A * A #CTRL & ENTER
## [1] 9
A/A #CTRL & ENTER
## [1] 1
A^A #CTRL & ENTER, tres a la Ava potencia
## [1] 27
sqrt(A) #CTRL & ENTER, raíz cuadrada de A
## [1] 1.732
exp(A) #CTRL & ENTER, exponencial, 2.718282 elevado a la potencia A
## [1] 20.09
log(A) #CTRL & ENTER, logaritmo natural o neperiano de A
## [1] 1.099
log(A, base = 10) #CTRL & ENTER, logaritmo base 10 de A
## [1] 0.4771
log(A, base = 2.5) #CTRL & ENTER, logaritmo en base 2.5 de A.
## [1] 1.199
cos(A/8) #CTRL & ENTER, coseno de A entre 8
## [1] 0.9305
sin(A/8) #CTRL & ENTER, seno de A entre 8
## [1] 0.3663
acos(A/8) #CTRL & ENTER, Arco coseno de A entre 8
## [1] 1.186
asin(A/8) #CTRL & ENTER, Arco seno de A entre 8
## [1] 0.3844
tan(A/8) #CTRL & ENTER, tangente de A entre 8
## [1] 0.3936
atan(A/8) #CTRL & ENTER, arco tangente de A entre 8
## [1] 0.3588
factorial(A) #CTRL & ENTER, factoriales de A
## [1] 6
(4 + A)/asin(A/8) #CTRL & ENTER
## [1] 18.21
((4 + A)/asin(A/8)) * factorial(A) #CTRL & ENTER
## [1] 109.3
# CONCATENAR --------------------------------
# Unas de las funciones mas recurrentes durante el uso de R es la de
# concatenar, << c() >>, que sirve para unir una serie de valores que se
# asignarán a un objeto. De esta forma el objeto que se crea puede
# contener mas de un valor. Como en todas las funciones, los argumentos
# dentro de la función concatenar van separados por coma, en este caso
# haremos un objeto numérico con 20 valores. Los argumentos de la función
# concatenar son cada uno de los 20 números que contendrá.
c(16, 18, 2, 4, 9, 11, 17, 19, 20, 14, 15, 13, 8, 7, 10, 3, 12, 6, 1, 5)
## [1] 16 18 2 4 9 11 17 19 20 14 15 13 8 7 10 3 12 6 1 5
# Al no asignar esta concatenación a un objeto R muestra el eco de la
# orden y el resultado que en este caso es la secuencia de números
B <- c(16, 18, 2, 4, 9, 11, 17, 19, 20, 14, 15, 13, 8, 7, 10, 3, 12, 6, 1, 5)
# Al asignar la concatenación a un objeto y ejecutar este código
# simplemente aparece el eco pero ningún resultado ya que este fue
# almacenado en el nombre dado al objeto, en este caso el nombre es B
# Ahora que tenemos dos objetos podemos hacer operaciones entre ellos, por
# ejemplo podemos sumar B + A
B + A
## [1] 19 21 5 7 12 14 20 22 23 17 18 16 11 10 13 6 15 9 4 8
# lo que nos da como resultado cada uno de los 20 valores concatenados que
# están en B mas tres que es el valor de A. Así podemos realizar cualquier
# tipo de operación, como por ejemplo
B^A #Cada elemento en B elevado al cubo
## [1] 4096 5832 8 64 729 1331 4913 6859 8000 2744 3375 2197 512 343
## [15] 1000 27 1728 216 1 125
B/A #Cada elemento en B dividido por tres
## [1] 5.3333 6.0000 0.6667 1.3333 3.0000 3.6667 5.6667 6.3333 6.6667 4.6667
## [11] 5.0000 4.3333 2.6667 2.3333 3.3333 1.0000 4.0000 2.0000 0.3333 1.6667
B * A #Cada elemento en B multiplicado por tres
## [1] 48 54 6 12 27 33 51 57 60 42 45 39 24 21 30 9 36 18 3 15
log(B, A) #El logaritmo en base tres de cada elemento en B
## [1] 2.5237 2.6309 0.6309 1.2619 2.0000 2.1827 2.5789 2.6801 2.7268 2.4022
## [11] 2.4650 2.3347 1.8928 1.7712 2.0959 1.0000 2.2619 1.6309 0.0000 1.4650
# Usualmente las operaciones entre los objetos tienen sentido cuando estos
# son de la misma longitud, es decir contienen el mismo número de
# elementos como los objetos C y D
C <- c(3, 6, 9, 12)
D <- c(4, 8, 16, 32)
# Asi en las operaciones entre estos dos objetos implican que el elemento
# en la posición uno del objeto C es modificado por el elemento uno en la
# posición uno del objeto D. El elemento en la posición dos del objeto C
# es modificado por el elemento en la posición dos del objeto D, y así
# sucesivamente
C + D
## [1] 7 14 25 44
# da como resultado 3 + 4 = 7, 6 + 8 = 14, 9 + 16 = 25, 12 + 32 = 44.
# Cuando los objetos no son de la misma longitud, usualmente uno debe ser
# un submúltiplo del otro y los elementos del vector de menor longitud se
# reciclan para efectuar las operaciones indicadas con cada uno de los
# elementos del objeto de mayor longitud.
B + C
## [1] 19 24 11 16 12 17 26 31 23 20 24 25 11 13 19 15 15 12 10 17
# Así los primeros cuatro elementos de B (16, 18, 2 y 4) se les suman
# respectivamente los valores almacenados en el objeto C, y estos cuatro
# elementos en C se reciclan para modificar a los elementos en B en la
# quinta, sexta, séptima y octava posición, se vuelven a reciclar para
# afectar a los elementos en B en la novena, décima, décimo primera y
# décimo segunda posición, y así sucesivamente hasta que los cuatro
# elementos en C modifican a los elementos en la décimo séptima, décimo
# octava, décimo novena y vigésima posiciones en B respectivamente.
# Si los objetos no son múltiplos o submúltiplos entre si, las operaciones
# se realizan de la misma forma pero dado que el reciclado del objeto mas
# pequeño siempre terminara siendo incompleto R nos da una advertencia <<
# warnning >> de que este fue el caso. Por ejemplo observe este ejemplo
# con el nuevo objeto E que solo contiene tres elementos
E <- c(9, 6, 3)
B
## [1] 16 18 2 4 9 11 17 19 20 14 15 13 8 7 10 3 12 6 1 5
B/E
## Warning: longer object length is not a multiple of shorter object length
## [1] 1.7778 3.0000 0.6667 0.4444 1.5000 3.6667 1.8889 3.1667 6.6667 1.5556
## [11] 2.5000 4.3333 0.8889 1.1667 3.3333 0.3333 2.0000 2.0000 0.1111 0.8333
length(A)
## [1] 1
length(B)
## [1] 20
length(C)
## [1] 4
length(D)
## [1] 4
length(E)
## [1] 3
# CREAR SECUENCIAS Y REPETICIONES ----------- Existen diferentes formas de
# crear secuencias y repeticiones en R. Las mas sencillas tienen que ver
# con secuencias de números enteros. La primera de estas formas es indicar
# en que número queremos comenzar colocar dos puntos << : >> e indicar el
# número en que queremos terminar.
1:30
## [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
## [24] 24 25 26 27 28 29 30
25:1
## [1] 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3
## [24] 2 1
-25:1
## [1] -25 -24 -23 -22 -21 -20 -19 -18 -17 -16 -15 -14 -13 -12 -11 -10 -9
## [18] -8 -7 -6 -5 -4 -3 -2 -1 0 1
10:-10
## [1] 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6
## [18] -7 -8 -9 -10
# La siguiente forma de crear secuencias implican intervalos en una
# secuencia diferentes a la unidad. Al igual que en los ejemplos
# anteriores debemos indicar en que número inicia, en que número termina,
# y además debemos indicar el intervalo que habrá entre cada par de
# números consecutivos. A diferencias de los ejemplos anteriores para esto
# debemos hacer uso de una función llamada << seq() >>
seq(from = 1, to = 30, by = 0.5)
## [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5 6.0 6.5 7.0 7.5
## [15] 8.0 8.5 9.0 9.5 10.0 10.5 11.0 11.5 12.0 12.5 13.0 13.5 14.0 14.5
## [29] 15.0 15.5 16.0 16.5 17.0 17.5 18.0 18.5 19.0 19.5 20.0 20.5 21.0 21.5
## [43] 22.0 22.5 23.0 23.5 24.0 24.5 25.0 25.5 26.0 26.5 27.0 27.5 28.0 28.5
## [57] 29.0 29.5 30.0
# Los nombres de los argumentos, como en cualquier función son opcionales.
# Cuando no se usan los nombres el orden en que aparecen determina la
# función que desempeñan.
seq(25, 1, -2)
## [1] 25 23 21 19 17 15 13 11 9 7 5 3 1
seq(-25, 1, 2)
## [1] -25 -23 -21 -19 -17 -15 -13 -11 -9 -7 -5 -3 -1 1
seq(10, -10, -2)
## [1] 10 8 6 4 2 0 -2 -4 -6 -8 -10
# Es muy importante tener en cuenta el signo del tercer argumento, el que
# determina el intervalo entre número contiguos en la secuencia ya que de
# nos ser el signo lógico según sean los valores de inicio y fin se
# producirá un mensaje de error. Por ejemplo si vamos a crear la secuencia
# empezando en seis negativo y terminando en 12 positivo con intervalo de
# dos unidades, este último elemento debe tener signo positivo lo que
# indica que a cada valor se le suman dos unidades para generar el
# siguiente valor en la secuencia.
seq(-6, 12, 2)
## [1] -6 -4 -2 0 2 4 6 8 10 12
# Si la secuencia va a ser inversa, es decir iniciando en 12 positivo y
# terminando en seis negativo, con el mismo intervalo de dos unidades, el
# tercer elemento deberá tener signo negativo, indicando que a cada
# elemento de la secuencia se le restan dos unidades para obtener el
# siguiente valor.
seq(12, -6, -2)
## [1] 12 10 8 6 4 2 0 -2 -4 -6
# De no respetar esta regla se producirá un mensaje de error << wrong sign
# in 'by' argument >>
seq(12, -6, 2)
## Error: wrong sign in 'by' argument
# Una variante al crear secuencias es que determinemos el valor de inicio,
# el valor en que terminará la secuencia y el número de elementos queremos
# que existan en la secuencia, y así R automáticamente calcula de que
# tamaño debe ser el intervalo entre los números contiguos de la
# secuencia. Para lograr esto el tercer argumento dentro de la fucnión <<
# seq() >> debe referirse al número de elementos que deseamos que contenga
# la secuencia por lo que hay que nombrarlo explícitamente de la siguiente
# manera
seq(3, 19, length = 25)
## [1] 3.000 3.667 4.333 5.000 5.667 6.333 7.000 7.667 8.333 9.000
## [11] 9.667 10.333 11.000 11.667 12.333 13.000 13.667 14.333 15.000 15.667
## [21] 16.333 17.000 17.667 18.333 19.000
# en esta secuencia que inicia en tres y termina en 19 R acomoda 25
# números que en este caso tienen un intervalo entre ellos de 0.666667
# Otras secuencias son de texto y pueden resultar útiles para generar
# variables categóricas de forma sencillas dentro del ambiente R. Estas
# secuencias son las letras del alfabeto y se presentan tanto en
# mayúsculas como en minúsculas y ya están predefinidas en R bajo los
# nombres de objeto << letters >> y << LETTERS >>
letters
## [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q"
## [18] "r" "s" "t" "u" "v" "w" "x" "y" "z"
LETTERS
## [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q"
## [18] "R" "S" "T" "U" "V" "W" "X" "Y" "Z"
# para crear repeticiones de una secuencia existen dos formas, repetir la
# secuencia completa un determinado número de veces, y repetir cada
# elemento de la secuencia un determinado número de veces, en esta segunda
# forma el número de repeticiones de cada elemento en la secuencia puede
# varia. Para ambos tipos de repeticiones usaremos la función << rep() >>
# que significa repetir. Esta función usa dos argumentos, el primero es la
# secuencia de valores u otros caracteres que se quieran repetir, y el
# segundo es el número de repeticiones. Similar al caso del tercer
# argumento en las secuencias, el segundo argumento de la función repetir,
# << times >>, puede tomar dos formas. La primera forma que es la opción
# predefinida y por lo tanto el nombre del argumento puede omitirse.
# Cuando << times >> es un indicador de cuantas veces se va a repetir la
# secuencia total este será un solo valor
rep(1:3, times = 4)
## [1] 1 2 3 1 2 3 1 2 3 1 2 3
# también puede usarse para indicar o cuantas veces se repetirá cada
# elemento de la secuencia si el argumento << times >> es una
# concatenación de la misma longitud que la secuencia a repetir.
rep(1:3, c(4, 3, 2))
## [1] 1 1 1 1 2 2 2 3 3
# Otra variante es un solo valor que indique cuantas veces se repetirá
# cada elemento de la secuencia y en este caso siempre deberá ser un solo
# valor.
rep(1:3, each = 3)
## [1] 1 1 1 2 2 2 3 3 3
# Aquí hay otras repeticiones usando los objetos predefinidos << letters
# >> y << LETTERS >>
rep(letters, 4)
## [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q"
## [18] "r" "s" "t" "u" "v" "w" "x" "y" "z" "a" "b" "c" "d" "e" "f" "g" "h"
## [35] "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y"
## [52] "z" "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p"
## [69] "q" "r" "s" "t" "u" "v" "w" "x" "y" "z" "a" "b" "c" "d" "e" "f" "g"
## [86] "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x"
## [103] "y" "z"
rep(LETTERS, 1:26) #A repetida una vez, B dos veces, C tres veces ... Z veintiseis veces
## [1] "A" "B" "B" "C" "C" "C" "D" "D" "D" "D" "E" "E" "E" "E" "E" "F" "F"
## [18] "F" "F" "F" "F" "G" "G" "G" "G" "G" "G" "G" "H" "H" "H" "H" "H" "H"
## [35] "H" "H" "I" "I" "I" "I" "I" "I" "I" "I" "I" "J" "J" "J" "J" "J" "J"
## [52] "J" "J" "J" "J" "K" "K" "K" "K" "K" "K" "K" "K" "K" "K" "K" "L" "L"
## [69] "L" "L" "L" "L" "L" "L" "L" "L" "L" "L" "M" "M" "M" "M" "M" "M" "M"
## [86] "M" "M" "M" "M" "M" "M" "N" "N" "N" "N" "N" "N" "N" "N" "N" "N" "N"
## [103] "N" "N" "N" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O"
## [120] "O" "P" "P" "P" "P" "P" "P" "P" "P" "P" "P" "P" "P" "P" "P" "P" "P"
## [137] "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q" "Q"
## [154] "R" "R" "R" "R" "R" "R" "R" "R" "R" "R" "R" "R" "R" "R" "R" "R" "R"
## [171] "R" "S" "S" "S" "S" "S" "S" "S" "S" "S" "S" "S" "S" "S" "S" "S" "S"
## [188] "S" "S" "S" "T" "T" "T" "T" "T" "T" "T" "T" "T" "T" "T" "T" "T" "T"
## [205] "T" "T" "T" "T" "T" "T" "U" "U" "U" "U" "U" "U" "U" "U" "U" "U" "U"
## [222] "U" "U" "U" "U" "U" "U" "U" "U" "U" "U" "V" "V" "V" "V" "V" "V" "V"
## [239] "V" "V" "V" "V" "V" "V" "V" "V" "V" "V" "V" "V" "V" "V" "V" "W" "W"
## [256] "W" "W" "W" "W" "W" "W" "W" "W" "W" "W" "W" "W" "W" "W" "W" "W" "W"
## [273] "W" "W" "W" "W" "X" "X" "X" "X" "X" "X" "X" "X" "X" "X" "X" "X" "X"
## [290] "X" "X" "X" "X" "X" "X" "X" "X" "X" "X" "X" "Y" "Y" "Y" "Y" "Y" "Y"
## [307] "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y" "Y"
## [324] "Y" "Y" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z"
## [341] "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z" "Z"
rep(c(letters, LETTERS), each = 3) #Concatenar letras minuscupas y mayusculas y repetir cada una de ellas tres veces
## [1] "a" "a" "a" "b" "b" "b" "c" "c" "c" "d" "d" "d" "e" "e" "e" "f" "f"
## [18] "f" "g" "g" "g" "h" "h" "h" "i" "i" "i" "j" "j" "j" "k" "k" "k" "l"
## [35] "l" "l" "m" "m" "m" "n" "n" "n" "o" "o" "o" "p" "p" "p" "q" "q" "q"
## [52] "r" "r" "r" "s" "s" "s" "t" "t" "t" "u" "u" "u" "v" "v" "v" "w" "w"
## [69] "w" "x" "x" "x" "y" "y" "y" "z" "z" "z" "A" "A" "A" "B" "B" "B" "C"
## [86] "C" "C" "D" "D" "D" "E" "E" "E" "F" "F" "F" "G" "G" "G" "H" "H" "H"
## [103] "I" "I" "I" "J" "J" "J" "K" "K" "K" "L" "L" "L" "M" "M" "M" "N" "N"
## [120] "N" "O" "O" "O" "P" "P" "P" "Q" "Q" "Q" "R" "R" "R" "S" "S" "S" "T"
## [137] "T" "T" "U" "U" "U" "V" "V" "V" "W" "W" "W" "X" "X" "X" "Y" "Y" "Y"
## [154] "Z" "Z" "Z"
## USAR CORCHETES PARA SOLICITAR INFORMACIÓN DE POSICIONES PARTICULARES DE
## UN OBJETO
LETTERS[1:3] # EXTRAE LAS PRIMERAS TRES LETRAS
## [1] "A" "B" "C"
rep(LETTERS[1:3], each = 5) #Repite cinco veces cada una de las primeras tres letras mayusculas
## [1] "A" "A" "A" "A" "A" "B" "B" "B" "B" "B" "C" "C" "C" "C" "C"
FACTOR1 <- rep(LETTERS[1:3], each = 5) #Asigna a un abjeto << FACTOR1 >> la repetición de letras hecha anteriormente
# MUESTRAS ALEATORIAS
sample(1:20) #Aleatoriza los valores de la secuencia, 1 al 20.
## [1] 13 8 10 5 19 17 15 20 14 6 12 18 3 4 9 1 11 2 16 7
sample(1:20)[1:15] #Aleatoriza los valores de la secuencia, 1 al 20 y nos mustra los primeros 15 valores especificandolo el los corchetes.
## [1] 7 13 10 20 14 16 15 11 5 8 9 4 6 1 17
sample(1:20, size = 15) #Aleatoriza los valores de la secuencia, 1 al 20 y nos muestra los primeros 15 valores especificándolo dentro de la función.
## [1] 11 5 7 14 15 6 18 1 13 12 16 8 20 19 4
sample(1:20, size = 15, replace = TRUE) #Aleatoriza los valores de la secuencia, 1 al 20 y nos muestra los primeros 15 valores, y los valores son tomados con reemplazo, es decir un número dado puede salir mas de una vez
## [1] 11 3 18 1 12 11 6 6 14 11 1 19 8 20 7
MUESTRA1 <- sample(1:20, size = 15, replace = TRUE) #Asigna los 15 valores de la función << sample() >> al objeto << MUESTRA1 >>
sort(MUESTRA1) #Ordena la muestra de valores en << MUESTRA1 >>
## [1] 1 2 3 4 5 5 6 7 9 10 13 16 17 18 18
mean(MUESTRA1) # Calcula la media de los 15 valores en << MUESTRA1 >>
## [1] 8.933
data.frame(FACTOR1, MUESTRA1) # Muestra la asociación en posiciones entres los objetos << MUESTRA1 >> y << FACTOR1 >>
## FACTOR1 MUESTRA1
## 1 A 3
## 2 A 9
## 3 A 5
## 4 A 6
## 5 A 17
## 6 B 5
## 7 B 1
## 8 B 13
## 9 B 18
## 10 B 4
## 11 C 2
## 12 C 7
## 13 C 16
## 14 C 18
## 15 C 10
mean(MUESTRA1[1:5])
## [1] 8
mean(MUESTRA1[6:10])
## [1] 8.2
mean(MUESTRA1[11:15])
## [1] 10.6
FACTOR2 <- sample(FACTOR1) # Aleatoriza el orden de los elementos en `<< FACTOR1 >>
data.frame(FACTOR2, MUESTRA1) #Muestra la asociación en posiciones entres los objetos << MUESTRA1 >> y << FACTOR2 >>
## FACTOR2 MUESTRA1
## 1 A 3
## 2 B 9
## 3 B 5
## 4 A 6
## 5 C 17
## 6 A 5
## 7 C 1
## 8 C 13
## 9 B 18
## 10 B 4
## 11 A 2
## 12 B 7
## 13 A 16
## 14 C 18
## 15 C 10
# Cuando los niveles dentro de un factor no estan ordenados se pueden usar
# funciones lógicas para extraer los valores deseados.
FACTOR2 == "B"
## [1] FALSE TRUE TRUE FALSE FALSE FALSE FALSE FALSE TRUE TRUE FALSE
## [12] TRUE FALSE FALSE FALSE
MUESTRA1[FACTOR2 == "B"] # Cuando usamos una función lógica dentro de los corchetes (que indican posiciones dentro de un objeto) R entiende que solo queremos ver los valores en las posiciones que cumplen la condición lógica
## [1] 9 5 18 4 7
mean(MUESTRA1[FACTOR2 == "A"])
## [1] 6.4
mean(MUESTRA1[FACTOR2 == "B"])
## [1] 8.6
mean(MUESTRA1[FACTOR2 == "C"])
## [1] 11.8
# La función << tapply() >> nos simplifica la vida. Tiene tres argumentos:
# 1) los valores a analizar, en este caso los 15 valores en << MUESTRA1
# >>. 2) El criterio para analizarlos, en este caso el << FCATOR2 >> que
# contiene cinco repeticiones de A, B y C aleatoriamente. 3) La función
# que se va a ejecutar, en este caso la media.
tapply(MUESTRA1, FACTOR2, mean)
## A B C
## 6.4 8.6 11.8