module-1-programming/Day2_1_R_Basics.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.\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](http://ggplot2.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 in at positions 3 and 1\n",
    "x[c(3, 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#returning an ordered vector\n",
    "x[order(x)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#omitting values\n",
    "x[-c(3, 1)]"
   ]
  },
  {
   "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)\n"
   ]
  },
  {
   "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": "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)"
   ]
  },
  {
   "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": [
    "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": {},
   "outputs": [],
   "source": [
    "?subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "subset(test_frame, b=='w')"
   ]
  },
  {
   "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": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<b>Basic structure of a function in R:</b>\n",
    "\n",
    "```#function documentation```\n",
    "\n",
    "```my_function <- function(my_input_argument) {```\n",
    "  \n",
    "  ```#some operation (s)```\n",
    "  \n",
    "  ```return(output)```\n",
    "}\n",
    "<div>"
   ]
  },
  {
   "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",
    " }\n",
    "\n",
    "fahrenheit_to_celsius(32)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple if, else statement in R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Structure of an if, else statement:</b>\n",
    "\n",
    "```if( ){\n",
    "statement 1\n",
    "} else {\n",
    "statement 2\n",
    "}```\n",
    "\n",
    "<div>"
   ]
  },
  {
   "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": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Structure of an if, else statement with multiple conditions:</b>\n",
    "\n",
    "```if ( ) {\n",
    "statement 1\n",
    "} else if ( ) {\n",
    "statement 2\n",
    "} else {\n",
    "statement 3\n",
    "}```\n",
    "\n",
    "<div>"
   ]
  },
  {
   "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": [
    "### For and While Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>For loop structure:</b>\n",
    "    \n",
    "```for () {\n",
    "if()  statement\n",
    "}```\n",
    "\n",
    "<div>"
   ]
  },
  {
   "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": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>While loop structure:</b>\n",
    "\n",
    "```while () {\n",
    "statement\n",
    "}```\n",
    "\n",
    "<div>"
   ]
  },
  {
   "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": [
    "### R practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "R has a number of built-in datasets. Just for practice, let's use one of R's existing datasets called mtcars. Remember, if you're not sure about how to get started, you can always google!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data(mtcars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "head(mtcars)"
   ]
  },
  {
   "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, “mtcars[,1]“, for values greater than “15.0“."
   ]
  },
  {
   "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",
    "\n",
    "21 21 22.8 21.4 18.7 18.1 24.4 22.8 19.2 17.8 16.4 17.3 15.2 32.4 30.4 33.9 21.5 15.5 15.2 19.2 27.3 26 30.4 15.8 19.7 21.4\n",
    "\n",
    "<div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Subset the dataframe, “mtcars” for rows with “mpg” greater than , or equal to, 21 miles per gallon."
   ]
  },
  {
   "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: 'Mazda RX4' 'Mazda RX4 Wag' 'Datsun 710' 'Hornet 4 Drive' 'Merc 240D' 'Merc 230' 'Fiat 128' 'Honda Civic' 'Toyota Corolla' 'Toyota Corona' 'Fiat X1-9' 'Porsche 914-2' 'Lotus Europa' 'Volvo 142E'\n",
    "\n",
    "<div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Subset “mtcars” for rows with “cyl” less than “6“, and “gear” 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: 'Datsun 710' 'Merc 240D' 'Merc 230' 'Fiat 128' 'Honda Civic' 'Toyota Corolla' 'Fiat X1-9' 'Volvo 142E'\n",
    "\n",
    "<div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Subset “mtcars” for rows greater than, or equal to, 21 miles per gallon. Also, select only the columns, “mpg” through “hp“."
   ]
  },
  {
   "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 have a 14 x 4 dataframe with only the listed columns and rows: 'Mazda RX4' 'Mazda RX4 Wag' 'Datsun 710' 'Hornet 4 Drive' 'Merc 240D' 'Merc 230' 'Fiat 128' 'Honda Civic' 'Toyota Corolla' 'Toyota Corona' 'Fiat X1-9' 'Porsche 914-2' 'Lotus Europa' 'Volvo 142E'\n",
    "\n",
    "<div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading R packages: ggplot2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every time you load a library you're adding a new environment to R. The library specific functions become available because R searches all environments for your function call. Sometimes you override an existing function by loading a new library. You can reference the package-specific function via the package specifier.\n",
    "\n",
    "Here we will continue to use the mtcars dataset to explore the ggplot2 library, a commonly used library for plotting graphs in R.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "library('ggplot2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ggplot works primarily with dataframes. We have to supply ggplot with a dataframe, in this case mtcars. As we go through ggplot, a key thing to notice is how the plot can continually be enhaanced by adding layers and themes (generally indicated by a ```+``` sign and a following statement) to an existing plot. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a ggplot data visualization cheat sheet for your own reference: https://github.com/rstudio/cheatsheets/blob/main/data-visualization-2.1.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with initializing a basic ggplot with the mtcars dataset, using the mpg and cyl columns of data from the mtcars dataframe. The aes() function is what we will use to specify the X and Y axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ggplot(mtcars, aes(x=mpg, y=cyl))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you see a blank ggplot? If so, don't worry, you did this step correctly. While we have x and y labels that match the columns we initialized the plot with, we don't see any plotted data. This is because ggplot does not make assumptions about the plot you are meaning to draw. Initializing the ggplot only tells ggplot what dataframe and what x and y columns from the dataframe should be used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's make a scatterplot. We will do this by adding on a layer using ```geom_point()```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ggplot(mtcars, aes(x=mpg, y=cyl)) + geom_point()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From here, we can add on a smoothing layer using the method \"lm\" to draw a line of best fit. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ggplot(mtcars, aes(x=mpg, y=cyl)) + geom_point() + geom_smooth(method='lm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The range of the x and y axes were automatically set by ggplot...but what if we want to change them. Let's add another couple of layers that adjust the range of the x and y axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ggplot(mtcars, aes(x=mpg, y=cyl)) + geom_point() + geom_smooth(method='lm')+ xlim(c(0, 25)) + ylim(c(0, 9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ggplot Practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have learned the basics of ggplot. Let's read in the hg19 chromosome size dataset and practice plotting with this dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hg19_chrom <- read.table('data/hg19.chrom.sizes.txt',header = FALSE, sep = \"\\t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "head(hg19_chrom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Now that we have loaded in the data, use ggplot to plot a barplot of the data where the x-axis is the chromosome name and the y-axis is the size of the chromosome. If you have extra time, try adding a title and informative x- and y-axis labels, try out different ggplot themes, etc.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "4.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}