<jupyter_start><jupyter_text>Introducción a RBioinformática para AntropologíaVamos a aprender a utilizar el lenguaje de programación para computación estadística R. Su primera versión fue publicada en 1995 y su primera versión estable apareció en febrero del año 2000. Es un lenguaje interpretado o sea que no requiere de compilador y está orientado a objetos por lo que las variables tienen diferentes tipos y cada tipo de variable tiene características y funciones inherentes. Este lenguaje tiene implementadas operaciones aritméticas de matrices, pruebas estadísticas clásicas, librerías de aleatorización, modelación (lineal y no lineal) y tiene un gran poder de generación de gráficos directamente publicables. Aunque muchos investigadores de diversas areas aprenden R simplemente para generar gráficos, recientemente se han liberado librerías de R relacionadas con campos de estudio particulares, incluyendo la bioinformática. Ejemplos de estas librerías son *ape* para la construcción de filogenias, *DESeq* para el análisis de transcriptomas y *vegan* que contiene análisis estadísticos usados en ecología.En la actualidad, es conveniente usar este tipo de programas para llevar a cabo investigación científica ya que podemos guardar y publicar la serie de comados utilizados para analizar los datos y generar las gráficas presentadas como resultados.La forma por defecto para trabajar con R es la línea de comandos, aunque hoy en día es muy común utilizar un ambiente integrado de desarrollo (IDE, por sus siglas en ingés) que es una aplicación de software que le facilita la gestión del código al usuario. Un ejemplo de IDE es RStudio que les recomiendo que instalen (https://rstudio.com/).Abran R ya sea desde la línea de comandos o desde RStudio y lleven a cabo estos pasos. Si R les dice que existe un error, no se asusten y lean lo que dice el error. Trabajar con lenguajes de programación implica tener paciencia y poner atención todo el tiempo pero una vez que se acostumbran van a ganar mucho.Si trabajan desde la línea de comando van a ver un símbolo '>' que significa que R está esperando una entrada. Es aquí en donde se ingresa el código y para que corra se presiona ENTER.En esta bitácora se muestran celdas de código numeradas y a continuación la respuesta que da la línea de comandos de R. Algunos de los resultados mostrados no corresponden. Fíjense cuales son.Las operaciones númericas son bastante intuitivas:<jupyter_code>1+1
2*2<jupyter_output><empty_output><jupyter_text>Recuerden el orden de las operaciones aritméticas:<jupyter_code>2+2*3<jupyter_output><empty_output><jupyter_text>Si tienen dudas con el orden, siempre pueden usar paréntesis:<jupyter_code>(2+2)*3
2/5<jupyter_output><empty_output><jupyter_text>Es posible obtener el residuo de una división de enteros:<jupyter_code>5%%3<jupyter_output><empty_output><jupyter_text>También podemos calcular potencias:<jupyter_code>2^4<jupyter_output><empty_output><jupyter_text>Hasta ahora hemos estado trabajando con un solo tipo de variable. Vamos a ver su nombre en R con la función **class**:<jupyter_code>class(1)<jupyter_output><empty_output><jupyter_text>El número 1 es un objeto, cuyo tipo es 'numeric' y los objetos de tipo numeric tienen implementadas las operaciones aritméticas, entre otras.Ahora vamos a crear una variable y le vamos a asignr el valor del número 5. Noten como el operador para asignar **<-** es literalmente una flecha que apunta a la izquierda:<jupyter_code>x <- 5<jupyter_output><empty_output><jupyter_text>Esta expresión se lee "x tráelo de 5."Noten que al presionar ENTER, R no respondió nada, simplemente porque no le preguntamos nada, al contrario de los comandos anteriores. Ssolo se limitóa guardar el valor de la variable.También se puede usar una flecha apuntando al otro lado que se lee como "llévalo a:"<jupyter_code>5 -> x<jupyter_output><empty_output><jupyter_text>Esta expresión se lee "5 llévalo a x." Yo recomiendo usar "<-" simplemente porque es más fácil de escribir en la mayoría de los teclados de computadora.Podemos pedirle a R que nos enseñe el valor de nuestra variable.<jupyter_code>x<jupyter_output><empty_output><jupyter_text>El tipo de la variable depende de lo que se le haya asignado:<jupyter_code>class(x)<jupyter_output><empty_output><jupyter_text>Por esa razón, es posible llevar a cabo operaciones ariméticas:<jupyter_code>x+2
x*3
x*x
x^x<jupyter_output><empty_output><jupyter_text>También se pueden asignar variables a partir de operaciones:<jupyter_code>y <- x*3
y
z <- x/y
z<jupyter_output><empty_output><jupyter_text>VectoresAhora vamos a escalar las operaciones trabajando con vectores, que son arreglos unidimiensionales de objetos. Para esto, vamos a sobreescribir el valor de x y vamos a juntar una seríe de números con la función **c** que significa: concatenar.<jupyter_code>x <- c(1,2,2,4,5)
x<jupyter_output><empty_output><jupyter_text>Veamos qué clase tiene nuestro objeto:<jupyter_code>class(x)<jupyter_output><empty_output><jupyter_text>La clase del vector corresponde a la clase de sus elementos.El número de elementos que tiene un vector define su tamaño, que se puede verificar con la función **length**.<jupyter_code>length(x)<jupyter_output><empty_output><jupyter_text>Es posible hacer operaciones aritméticas con vectores.<jupyter_code>x+1
x*2
x^4
x*x<jupyter_output><empty_output><jupyter_text>Es posible usar el operador ':' para generar vectores de números enteros consecutivos:<jupyter_code>x <- 1:5
x<jupyter_output><empty_output><jupyter_text>MatricesCrear matrices es un poco más complicado. Con tal fin, vamos a usar la función **matrix** que tiene tres argumentos básicos:data: son los valores que va a contener la matriz.nrow: número de filas.ncol: número de columnas.<jupyter_code>y <- matrix(data=0, nrow=2, ncol=2)
y<jupyter_output><empty_output><jupyter_text>Veamos el tipo de variable de y.<jupyter_code>class(y)<jupyter_output><empty_output><jupyter_text>Los objetos de tipo 'matrix' también tienen tamaño:<jupyter_code>length(y)<jupyter_output><empty_output><jupyter_text>Además, las matrices tienen dimensiones que se pueden ver con la función **dim**.<jupyter_code>dim(y)<jupyter_output><empty_output><jupyter_text>Dos filas y dos columnas.Miren como se puede simplificar la declaración de los argumentos en la función matrix, aquí el orden de los argumentos define su significado. También fíjense en el orden en el cual se están asignando los datos en la matriz.<jupyter_code>y <- matrix(1:9,3,3)
y
y <- matrix(1:12,3,4)
y
dim(y)
y <- matrix(1:12,4,3)
y
dim(y)<jupyter_output><empty_output><jupyter_text>Las matrices también tienen implementadas las operaciones aritméticas.<jupyter_code>y+1
y*2
y^3
y/4<jupyter_output><empty_output><jupyter_text>Regularmente necesitamos transponer una matriz, es decir, cambiar sus filas por sus columnas y se hace con la función **t**:<jupyter_code>t(y)<jupyter_output><empty_output><jupyter_text>Siguiendo las reglas del álgebra lineal, podemos hacer operaciones de matrices con vectores y matrices con matrices:<jupyter_code>x <- (1,2,3,4)
y + x
y * x
z <- matrix(2:13,4,3)
z
y+z
y*z+1<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.06596638655462185, 'fraction_numerical': 0.01050420168067227, 'mean_word_length': 6.508937960042061, 'pattern_counts': {'":': 0, '<': 114, '<?xml version=': 0, '>': 103, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '25', 'dir': 'jupyter-structured-clean-dedup', 'id': '31892', 'license': 'MIT', 'n_tokens_mistral': 2505, 'n_tokens_neox': 2473, 'n_words': 871, 'path': 'tutoriales/R_intro.ipynb', 'repo_name': 'miferg/stats', 'size': '7140'}