module-1-programming/Day1_2_R.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Overview of R:</b> \n",
    "\n",
    "- R is a widely used programming language and as such has many resources available. If you're looking to do some data wrangling chances are someone before you has already had to do the same thing you're about to do and maybe even written a package for those specific operations so it's usually worth searching around for the specific analysis or visualization you need to do. \n",
    "\n",
    "- [RStudio](https://www.rstudio.com/) is a quite user-friendly interface and has some great capabilities when plotting and debugging. You can always run R in jupyter though, like we are doing here!\n",
    "\n",
    "- RStudio also provides several [cheatsheets](https://www.rstudio.com/resources/cheatsheets) for some of the most commonly used functionalities.\n",
    "\n",
    "- Additionally, when you know the name of a function you can directly access the documentation for said function by entering: ?functionOfInterest.\n",
    "\n",
    "- The power of R lies both in it's statistical capabilities as well as in the various plotting options to visualize the data. Higher level visualizations are usually performed using [ggplot2](https://ggplot2.tidyverse.org/) which has an enormous range of possibilities. You can find some examples in the [R Graph Gallery](http://www.r-graph-gallery.com/)\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we will be covering the basics of R. The goal is for you to be able to interpret R code that will be used in future modules in this class. Here is a cheat sheet for R basics that may be a helpful resource for you along the way:\n",
    "- https://iqss.github.io/dss-workshops/R/Rintro/base-r-cheat-sheet.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting started : R can be used to perform simple operations\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# addition\n",
    "4 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# subtraction\n",
    "4 - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplication\n",
    "5 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# division\n",
    "5/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# raise a number to a power\n",
    "2^3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# take a root\n",
    "sqrt(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### R data types "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# character: \"a\", \"swc\"\n",
    "c <- 'c'\n",
    "typeof(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# numeric: 2, 15.5\n",
    "n <- 2.0\n",
    "typeof(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# integer: 2L (the L tells R to store this as an integer)\n",
    "i <- 2L\n",
    "typeof(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# logical: TRUE, FALSE\n",
    "l <- TRUE\n",
    "typeof(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basics of data structures in R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Atomic Vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A vector is a simple data structure in R. It can be used to make more complex data structures in R. Atomic vectors can only contain one type of data: logical, integer, double, character. They are one-dimensional and can be initialized with ```c()```. Let's start by making a vector and storing it as variable x:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- c(3,1,2,4)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we mentioned earlier, they can only store one type of data. In this case, we are storing numerical data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#length of vector\n",
    "length(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#returning elements at positions 3 and 1\n",
    "x[c(3, 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#omitting values\n",
    "x[-c(3, 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#returning an ordered vector\n",
    "x[order(x)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can pair vectors with mathematical functions. Here we see that applying a mathematical function to x applies it to all elements of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqrt(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists\n",
    "A list in R is still a vector but (unlike an atomic vector) we are able to stores different elements in a list, where each element can be of a different type\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize with list()\n",
    "my.list <- list(c(1:3), 'a', c(TRUE, FALSE))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my.list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# can name each element\n",
    "my.named.list <- list(one = c(1:3), two = 'a', three = c(TRUE, FALSE))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my.named.list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# access specific list elements\n",
    "my.named.list$one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my.named.list[['two']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my.named.list[[3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lists are made up of atomic vectors or other lists\n",
    "long.list <- list(first = 1, second = list(1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "long.list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrices are multi-dimensional data structures that can only hold one type of data (usually numeric). A Matrix is a sub-category of Arrays and only has two dimensions while Arrays can have more\n",
    "\n",
    "\n",
    "Let's first make a matrix using the following syntax:\n",
    "\n",
    "```matrix(data, nrow, ncol, byrow, dimnames)```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here, we make a matrix, M, with 4 rows and 3 columns with numbers going sequentially from 3 to 14\n",
    "M <- matrix(c(3:14), nrow = 4, ncol =3, byrow = TRUE)\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#check the dimensions of the matrix\n",
    "dim(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding row and column names to our matrix\n",
    "rownames <- c(\"a\", \"b\", \"c\", \"d\")\n",
    "colnames <- c(\"e\", \"f\", \"g\")\n",
    "P <- matrix(c(3:14), nrow = 4, ncol=3, byrow = TRUE, dimnames = list(rownames, colnames))\n",
    "print(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#all elements of matrices should be of the same type\n",
    "typeof((M))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want to access a certain element of the matrix?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#accessing the element in the first row, third column using column and row numbers\n",
    "P[1,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#accessing the element in the first row, third column using column and row names\n",
    "P['a','g']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#accessing all elements in a row of the matrix\n",
    "P[3,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#accessing all elements in a column\n",
    "P[,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create another matrix to be able to try out some matrix mathematics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "J <- matrix(c(3:14), nrow = 4, ncol=3, byrow = FALSE, dimnames = list(rownames, colnames))\n",
    "print(J)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just a reminder, here is how our matrix P looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add the matrices.\n",
    "addition_result <- P + J\n",
    "print(\"Result of addition:\")\n",
    "print(addition_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subtract the matrices\n",
    "subtraction_result <- P - J\n",
    "print(\"Result of subtraction:\")\n",
    "print(subtraction_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiply the matrices.\n",
    "mult_result <- P * J\n",
    "print(\"Result of multiplication:\")\n",
    "print(mult_result)\n",
    "\n",
    "#note this is not the same thing as taking the dot product (commonly referred to as matrix multiplication)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Divide the matrices\n",
    "div_result <- P / J\n",
    "print(\"Result of division:\")\n",
    "print(div_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Earlier, we had said that vectors can be used to build more complex data structures. Now let's see how we can use vectors to build more complex data structures by using multiple vectors to create a data frame, one of the most commonly used data structures. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a <- c(1,0,1,1)\n",
    "b <- c('w','r','h','i')\n",
    "c <- c(5,6,3,1)\n",
    "\n",
    "test_frame <-data.frame(a,b,c)\n",
    "test_frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Under the hood, data frames are lists and can be accessed as such"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_frame$a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But they also have matrix-like properties: they possess rows and columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim(test_frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_frame[,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_frame[1,]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic dataframe subsetting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often you'll have a lot of data stored in dataframes and won't be able to look at it all at once. To get an idea of the first and last rows of the data frame use the commands `head` and `tail`, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "head(test_frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tail(test_frame)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also subset the dataframe using ```subset()```. Not familiar with how to use the subset function? Let's figure out how to use this function using ```?```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "?subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "subset(test_frame, b=='w')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, you can also subset a dataframe using logical statements and `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#first let's see what happens when we apply a logical statement to a matrix column\n",
    "test_frame$b == 'w'\n",
    "test_frame[,2] == 'w'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#now let's feed the logical statement into []\n",
    "logical <- test_frame$b == 'w'\n",
    "test_frame[logical,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can also combine these into one line\n",
    "test_frame[test_frame$b == 'w',]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "Your turn! Use your preferred method to subset test_frame to only contain rows where the sum of the two integer values is greater than 4.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like in python, we can create functions in R. However, the syntax is slightly different.\n",
    "\n",
    "In general, remember that functions are used to link several operations which can be repeated by typing just one command instead of having to re-type the whole thing. If you find yourself doing something over and over again it should probably go into a function...\n",
    "\n",
    "Functions help you clean up your code and make things more organized. Better organized means both less mistakes and it's easier to catch mistakes.\n",
    "\n",
    "The best thing about functions it that once you create and adequately test your function, you can continue to re-use it from analysis to analysis!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Basic structure of a function in R:</b>\n",
    "\n",
    "```\n",
    "#function documentation\n",
    "my_function <- function(my_input_argument) {\n",
    "    #some operation(s)\n",
    "    return(output)\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fahrenheit_to_celsius <- function(temp_F){\n",
    "    temp_C <- (temp_F - 32) * 5 / 9\n",
    "    return(temp_C)\n",
    " }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fahrenheit_to_celsius(32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple if, else statement in R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Structure of an if, else statement:</b>\n",
    "\n",
    "```\n",
    "if( ){\n",
    "    statement 1\n",
    "} else {\n",
    "    statement 2\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y <- 4\n",
    "\n",
    "if(y > 0){\n",
    "    print(\"Non-negative number\")\n",
    "} else {\n",
    "    print(\"Negative number\")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding multiple conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Structure of an if, else statement with multiple conditions:</b>\n",
    "\n",
    "```\n",
    "if ( ) {\n",
    "    statement 1\n",
    "} else if ( ) {\n",
    "    statement 2\n",
    "} else {\n",
    "    statement 3\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if ( y > 5) {\n",
    "    print(\"y is larger than 5\")\n",
    "} else if ( y == 5) {\n",
    "    print(\"y is 5\")\n",
    "} else {\n",
    "    print(\"y is less than 5\")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "Your turn! Write a function which takes a numeric input and returns the log10. If the input number is negative, instead print out \"Input is negative number\".\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For and While Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>For loop structure:</b>\n",
    "    \n",
    "```\n",
    "for () {\n",
    "    statement\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- c(2,5,3,9,8,11,6)\n",
    "count <- 0\n",
    "for (val in x) {\n",
    "    if(val %% 2 == 0)  count = count+1\n",
    "}\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>While loop structure:</b>\n",
    "\n",
    "```\n",
    "while () {\n",
    "    statement\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i <- 1\n",
    "while (i < 6) {\n",
    "    print(i)\n",
    "    i <- i+1\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alternatives to Loops\n",
    "Although loops are very useful and easy to understand, sometimes you want to make your code more streamlined. There are multiple ways in R to avoid loops and use less lines of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often loops aren't necessary, if you can find a function that does what you want it will automatically apply to every element in a vector!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my.vector <- seq(1,20,4)\n",
    "my.vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#instead of using a for loop\n",
    "for (val in my.vector){\n",
    "    print(log10(val))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#just use the log10 function directly on the vector\n",
    "log10(my.vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### lapply and sapply\n",
    "`lapply` will apply a function to every element in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my.list <- list(a = c(1,2,3), b = c(7,8,9), c = c(4,5,6))\n",
    "my.list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can't use a function on a list#\n",
    "max(my.list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#instead let's use lapply, but first let's figure out how to use it\n",
    "?lapply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max.values <- lapply(my.list, max)\n",
    "max.values\n",
    "typeof(max.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#this output isn't in an easy to use format, let's change that with unlist\n",
    "unlist(max.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#and what about sapply, how does that compare?\n",
    "sapply(my.list, max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### apply\n",
    "`apply` will apply a function to every row/column in a matrix or dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my.data <- data.frame(a = c(1,2,3), b = c(7,8,9), c = c(4,5,6))\n",
    "my.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#again, let's figure out how to use apply\n",
    "?apply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "apply(my.data, 1, max)\n",
    "apply(my.data, 2, max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "Your turn! Use your preferred apply commands to get the minimum values in my.list and my.data\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### R practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "Let's practice using R to analyze some data using data manipulation and visualizations. We will use publicly-available data <a href=\"https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE166925)\">GSE166925</a> from NCBI GEO with inflammatory bowel disease and colorectal cancer patients.\n",
    "     \n",
    "<br><br> \n",
    "In this practice, we will only focus on the meta-data associated with the RNA-seq data. A metadata file is the one with information about the samples (ex: sample ID, disease status, gender, etc.) where each row represents a sample and columns contain the various information\n",
    "<br><br>     \n",
    "Remember, if you're not sure about how to get started, you can always google!\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Manipulation\n",
    "We need to format the data in a way that we can use for later analyses/visualizations.\n",
    "\n",
    "Let's read in the sample metadata table that was saved to GSE166925-meta.tsv (file location: `~/module-1-programming/data/GSE166925-meta.tsv`) into a `meta` dataframe object. We can use the [`read.table()`](https://www.rdocumentation.org/packages/utils/versions/3.6.2/topics/read.table) function to generate dataframes from files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meta <- read.table('data/GSE166925-meta.tsv',sep='\\t')\n",
    "head(meta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also use the title column as the index instead of the GSM IDs using `rownames()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rownames(meta) <- meta$title\n",
    "head(meta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Based on what we've covered so far, take a minute to try out some of these exercises:***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.  Subset the vector, “meta[,6]“, for values greater than “50“."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "You should be getting a vector with the following values: \n",
    "56 63 56 55 52 59 62 60 69 55 77 60 73 73 68 68 77 77 73 70 64 NA 60 80 85 62 68 88 61 64 65 76 60 68 73 80 60 72 66 66 76 83 54 79 83 69 64 63 73 79 57 76\n",
    "\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Subset the dataframe, “meta” for rows with “patient_age.ch1” greater than , or equal to, 80 years old."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "You should get a dataframe with only the following rows: \"CRC_N_LI_F_65\" \"CRC_N_LI_M_67\" \"CRC_N_LI_M_70\" \"CRC_N_LI_F_78\" \"CRC_N_LI_F_86\" \"CRC_N_LI_M_89\"\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Subset “meta” for rows with “gender.ch1” is “female“, and “nancy_score.ch1” exactly equal to “4“."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "You should get a dataframe with only the following rows: \"UC_NA_LI_F_2\" \"CD_I_SI_F_3\"  \"CD_I_SI_F_31\" \"UC_I_LI_F_45\"\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizations using Basic Plots\n",
    "Let's explore the sample metadata by creating some plots using the `meta` dataframe.\n",
    "\n",
    "Let's first look at the distribution of patient ages in our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Histograms:**\n",
    "\n",
    "[`hist()`](https://www.datamentor.io/r-programming/histogram/) : generates a histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist(meta$patient_age.ch1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, generate a bar plot using [`barplot()`](https://www.statmethods.net/graphs/bar.html) of the gender. \n",
    "\n",
    "The input for `barplot()` is a table of counts for each condition, not a list of the conditions. \n",
    "\n",
    "Ex: instead of a list/vector with \"female\", \"female\", \"female\", \"male\", we need to use the [`table()`](https://www.statology.org/table-function-in-r/) function to get the counts, female: 3 and male: 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gender_table <- table(meta$gender.ch1)\n",
    "gender_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "barplot(gender_table)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h3>R Practice for basic visualizations: barplot</h3><br>\n",
    "    \n",
    "<p>\n",
    "    Generate a stacked bar plot using <code>barplot()</code> of the disease and inflammation status. The x-axis should be divided by disease, and each disease will be subdivided into inflamed/uninflamed.\n",
    "    \n",
    "Hints:\n",
    "    <ul>\n",
    "        <li>You can look here for <a href=\"https://www.statmethods.net/graphs/bar.html\">examples</a> </li>\n",
    "<li>Generate the counts table with disease and inflammation status</li>\n",
    "<li>You can use the <code>beside=</code> parameter when calling <code>barplot()</code> so the groups aren't stacked on top of each other</li>\n",
    "<li>Use the <code>legend=</code> parameter to include the legend in the plot</li>\n",
    "<li>You can also add title (<code>main=</code>), x-axis label (<code>xlab=</code>), y-axis label (<code>ylab=</code>), colors (<code>col=</code>)</li>\n",
    "    </ul>\n",
    "        </p>\n",
    "    \n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table(meta$disease.ch1, meta$inflammation_status.ch1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "barplot(table(meta$inflammation_status.ch1, meta$disease.ch1), beside=T,legend=T)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R [conda env:programming-R]",
   "language": "R",
   "name": "conda-env-programming-R-r"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "4.2.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}