R_Genomics_R_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducing R and Jupyter Notebooks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using functions in R, without needing to master them\n",
    "`?`\n",
    "`args()round`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning message in download.file(url = \"https://raw.githubusercontent.com/ggrimes/genomics_r/master/rawdata/combined_tidy_vcf.csv\", :\n",
      "“URL https://raw.githubusercontent.com/ggrimes/genomics_r/master/rawdata/combined_tidy_vcf.csv: cannot open destfile '../rawdata/combined_tidy_vcf.csv', reason 'No such file or directory'”\n",
      "Warning message in download.file(url = \"https://raw.githubusercontent.com/ggrimes/genomics_r/master/rawdata/combined_tidy_vcf.csv\", :\n",
      "“download had nonzero exit status”\n"
     ]
    }
   ],
   "source": [
    "download.file(url = \"https://raw.githubusercontent.com/ggrimes/genomics_r/master/rawdata/combined_tidy_vcf.csv\",\n",
    "              destfile  =file.path(\"..\",\"rawdata\",\"combined_tidy_vcf.csv\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "download.file(url = \"https://raw.githubusercontent.com/ggrimes/genomics_r/master/rawdata/combined_tidy_vcf.csv\",destfile  =file.path(\"combined_tidy_vcf.csv\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>'combined_tidy_vcf.csv'</li><li>'R_Genomics_R_Basics.ipynb'</li><li>'Rtest.ipynb'</li><li>'Untitled Folder'</li><li>'Untitled.ipynb'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'combined\\_tidy\\_vcf.csv'\n",
       "\\item 'R\\_Genomics\\_R\\_Basics.ipynb'\n",
       "\\item 'Rtest.ipynb'\n",
       "\\item 'Untitled Folder'\n",
       "\\item 'Untitled.ipynb'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'combined_tidy_vcf.csv'\n",
       "2. 'R_Genomics_R_Basics.ipynb'\n",
       "3. 'Rtest.ipynb'\n",
       "4. 'Untitled Folder'\n",
       "5. 'Untitled.ipynb'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"combined_tidy_vcf.csv\"     \"R_Genomics_R_Basics.ipynb\"\n",
       "[3] \"Rtest.ipynb\"               \"Untitled Folder\"          \n",
       "[5] \"Untitled.ipynb\"           "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=language-r><code>function (x, digits = 0) \n",
       "NULL</code></pre>"
      ],
      "text/latex": [
       "\\begin{minted}{r}\n",
       "function (x, digits = 0) \n",
       "NULL\n",
       "\\end{minted}"
      ],
      "text/markdown": [
       "```r\n",
       "function (x, digits = 0) \n",
       "NULL\n",
       "```"
      ],
      "text/plain": [
       "function (x, digits = 0) \n",
       "NULL"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "args(round)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# R Basics\n",
    "\n",
    "\n",
    "* Be able to create the most common R objects including vectors\n",
    "\n",
    "* Understand that vectors have modes, which correspond to the type of data they contain\n",
    "\n",
    "* Be able to use arithmetic operators on R objects\n",
    "\n",
    "* Be able to retrieve (subset), name, or replace, values from a vector\n",
    "\n",
    "* Be able to use logical operators in a subsetting operation\n",
    "\n",
    "* Understand that lists can hold data of more than one mode and can be indexed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating objects in R\n",
    "\n",
    "Objects in R are like containers for data.\n",
    "\n",
    "You will need to use the assigment operators below to create an object\n",
    "\n",
    "* `<-`\n",
    "* `->`\n",
    "* `=`\n",
    "\n",
    "This line creates the object 'a' and assigns it the value '1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "1"
      ],
      "text/latex": [
       "1"
      ],
      "text/markdown": [
       "1"
      ],
      "text/plain": [
       "[1] 1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a <-1\n",
    "1 -> a\n",
    "a=1\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding object data types (modes)\n",
    "\n",
    "In R, every object has two properties:\n",
    "\n",
    "* Length: How many distinct values are held in that object\n",
    "\n",
    "* Mode: What is the classification (type) of that object.\n",
    "\n",
    "We will get to the \"length\" property later in the lesson. \n",
    "\n",
    "The “mode” property corresponds to the type of data an object represents. \n",
    "\n",
    "The most common modes you will encounter in R are:\n",
    " \n",
    "* numeric: Numbers such floating point,decimals and integers "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'numeric'"
      ],
      "text/latex": [
       "'numeric'"
      ],
      "text/markdown": [
       "'numeric'"
      ],
      "text/plain": [
       "[1] \"numeric\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "'numeric'"
      ],
      "text/latex": [
       "'numeric'"
      ],
      "text/markdown": [
       "'numeric'"
      ],
      "text/plain": [
       "[1] \"numeric\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "'numeric'"
      ],
      "text/latex": [
       "'numeric'"
      ],
      "text/markdown": [
       "'numeric'"
      ],
      "text/plain": [
       "[1] \"numeric\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mode(1)\n",
    "mode(1.1)\n",
    "mode(1e6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* character a sequence of one or more letters or numbers in single `''` or double `\"\"` quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'character'"
      ],
      "text/latex": [
       "'character'"
      ],
      "text/markdown": [
       "'character'"
      ],
      "text/plain": [
       "[1] \"character\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "'character'"
      ],
      "text/latex": [
       "'character'"
      ],
      "text/markdown": [
       "'character'"
      ],
      "text/plain": [
       "[1] \"character\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "'character'"
      ],
      "text/latex": [
       "'character'"
      ],
      "text/markdown": [
       "'character'"
      ],
      "text/plain": [
       "[1] \"character\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mode(\"a\")\n",
    "mode('a')\n",
    "mode('1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Logical\tBoolean values,  TRUE or FALSE\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mathematical and functional operations on objects\n",
    "\n",
    "R has a number of mathematical operators that you can use with numeric data types\n",
    "\n",
    "* `+`\taddition\n",
    "* `-`\tsubtraction\n",
    "* `*`\tmultiplication\n",
    "* `/`\tdivision\n",
    "* `^` or `**`\texponentiation\n",
    "* `a%%b`\tmodulus (returns the remainder after division)  \n",
    "\n",
    "These can be used with literal numbers:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2.66666666666667"
      ],
      "text/latex": [
       "2.66666666666667"
      ],
      "text/markdown": [
       "2.66666666666667"
      ],
      "text/plain": [
       "[1] 2.666667"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(2^2)/1.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And importantly, can be used on any object that evaluates to (i.e. interpreted by R) a numeric object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "1"
      ],
      "text/latex": [
       "1"
      ],
      "text/markdown": [
       "1"
      ],
      "text/plain": [
       "[1] 1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "100"
      ],
      "text/latex": [
       "100"
      ],
      "text/markdown": [
       "100"
      ],
      "text/plain": [
       "[1] 100"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a\n",
    "a*100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectors\n",
    "\n",
    "Vectors are probably the most used commonly used object type in R. \n",
    "\n",
    "A vector is a collection of values that are all of the same data type (numeric, characters, logical). \n",
    "\n",
    "One of the most common ways to create a vector is to use the `c()` function - the  “combine” function. \n",
    "\n",
    "Inside the function you may enter one or more values; \n",
    "\n",
    "for multiple values, separate each value with a comma: `,`\n",
    "\n",
    "\n",
    "Create the vector snp_genes using these gene names \"OXTR\", \"ACTN3\", \"AR\", \"OPRM1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "snp_genes<-c(\"OXTR\", \"ACTN3\", \"AR\", \"OPRM1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the mode and length of the snp_genes object `mode()` and `length()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful function that gives both of these pieces of information is the `str()` (structure) function.\n",
    "What is the structure of the object snp_genes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " chr [1:4] \"OXTR\" \"ACTN3\" \"AR\" \"OPRM1\"\n"
     ]
    }
   ],
   "source": [
    "?str()\n",
    "str(snp_genes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating and Subsetting vectors\n",
    "\n",
    "Let’s create a few more vectors to play around with:\n",
    "\n",
    "* snps  that contains rs53576, rs1815739, rs6152, rs1799971\n",
    "\n",
    "* snp_chromosomes that contains 3, 11, X, 6\n",
    "\n",
    "* snp_positions that contains 8762685, 66560624, 67545785, 154039662\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Some interesting human SNPs\n",
    "snps <- c('rs53576', 'rs1815739', 'rs6152', 'rs1799971')\n",
    "snp_chromosomes <- c('3', '11', 'X', '6')\n",
    "snp_positions <- c(8762685, 66560624, 67545785, 154039662)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we have vectors, one thing we may want to do is specifically retrieve one or more values from our vector. \n",
    "\n",
    "To do so, we use bracket notation. \n",
    "\n",
    "We type the name of the vector followed by square brackets. `[]`\n",
    "\n",
    "In those square brackets we place the index (e.g. a number) in that bracket as follows:\n",
    "\n",
    "Note in R index start from 1\n",
    "\n",
    "\n",
    "Get the 3rd value in the snp_genes vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'AR'"
      ],
      "text/latex": [
       "'AR'"
      ],
      "text/markdown": [
       "'AR'"
      ],
      "text/plain": [
       "[1] \"AR\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_genes[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding to, removing, or replacing values in existing vectors\n",
    "\n",
    "Once you have an existing vector, you may want to add a new item to it. \n",
    "\n",
    "To do so, you can use the `c()` function again to add your new value:\n",
    "\n",
    "\n",
    "Add the gene 'CYP1A1' and 'APOA5' to our list of snp genes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "6"
      ],
      "text/latex": [
       "6"
      ],
      "text/markdown": [
       "6"
      ],
      "text/plain": [
       "[1] 6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_genes<-c(snp_genes,\"CYP1A1\",\"APOA5\")\n",
    "length(snp_genes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using a negative index `-` will return a version a vector with that index’s value removed:\n",
    "\n",
    "Remove the sixth entry from snp_genes vector.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>'OXTR'</li><li>'ACTN3'</li><li>'AR'</li><li>'OPRM1'</li><li>'CYP1A1'</li><li>'APOA5'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'OXTR'\n",
       "\\item 'ACTN3'\n",
       "\\item 'AR'\n",
       "\\item 'OPRM1'\n",
       "\\item 'CYP1A1'\n",
       "\\item 'APOA5'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'OXTR'\n",
       "2. 'ACTN3'\n",
       "3. 'AR'\n",
       "4. 'OPRM1'\n",
       "5. 'CYP1A1'\n",
       "6. 'APOA5'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"OXTR\"   \"ACTN3\"  \"AR\"     \"OPRM1\"  \"CYP1A1\" \"APOA5\" "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>'OXTR'</li><li>'ACTN3'</li><li>'AR'</li><li>'OPRM1'</li><li>'CYP1A1'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'OXTR'\n",
       "\\item 'ACTN3'\n",
       "\\item 'AR'\n",
       "\\item 'OPRM1'\n",
       "\\item 'CYP1A1'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'OXTR'\n",
       "2. 'ACTN3'\n",
       "3. 'AR'\n",
       "4. 'OPRM1'\n",
       "5. 'CYP1A1'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"OXTR\"   \"ACTN3\"  \"AR\"     \"OPRM1\"  \"CYP1A1\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_genes\n",
    "snp_genes[-6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can remove that value from our vector by overwriting it with this expression:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>'OXTR'</li><li>'ACTN3'</li><li>'AR'</li><li>'OPRM1'</li><li>'CYP1A1'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'OXTR'\n",
       "\\item 'ACTN3'\n",
       "\\item 'AR'\n",
       "\\item 'OPRM1'\n",
       "\\item 'CYP1A1'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'OXTR'\n",
       "2. 'ACTN3'\n",
       "3. 'AR'\n",
       "4. 'OPRM1'\n",
       "5. 'CYP1A1'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"OXTR\"   \"ACTN3\"  \"AR\"     \"OPRM1\"  \"CYP1A1\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_genes_bak<-snp_genes\n",
    "snp_genes <- snp_genes[-6]\n",
    "snp_genes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also explicitly rename or add a value to our index using double bracket notation `[]` and assigment operatoor `<-`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>'OXTR'</li><li>'ACTN3'</li><li>'AR'</li><li>'OPRM1'</li><li>'CYP1A1'</li><li>NA</li><li>'APOA5'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'OXTR'\n",
       "\\item 'ACTN3'\n",
       "\\item 'AR'\n",
       "\\item 'OPRM1'\n",
       "\\item 'CYP1A1'\n",
       "\\item NA\n",
       "\\item 'APOA5'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'OXTR'\n",
       "2. 'ACTN3'\n",
       "3. 'AR'\n",
       "4. 'OPRM1'\n",
       "5. 'CYP1A1'\n",
       "6. NA\n",
       "7. 'APOA5'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"OXTR\"   \"ACTN3\"  \"AR\"     \"OPRM1\"  \"CYP1A1\" NA       \"APOA5\" "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_genes[7]<- \"APOA5\"\n",
    "snp_genes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical Subsetting\n",
    "\n",
    "`TRUE`\n",
    "`FALSE`\n",
    "\n",
    "There is one last set of  subsetting capabilities we want to introduce. \n",
    "\n",
    "It is possible within R to retrieve items in a vector based on a logical evaluation or numerical comparison. \n",
    "\n",
    "E.g. \n",
    "\n",
    "let’s say we wanted get all of the SNPs in our vector of SNP positions that were greater than 100,000,000. \n",
    "\n",
    "We could  use the logical operator: `>` (greater than) on the vector snp_positions to help us.\n",
    "\n",
    "In the square brackets you place the name of the vector followed by the comparison operator and (in this case) a numeric value.\n",
    "\n",
    "Get all of the SNPs in our vector of SNP positions that were greater than 100,000,000. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "154039662"
      ],
      "text/latex": [
       "154039662"
      ],
      "text/markdown": [
       "154039662"
      ],
      "text/plain": [
       "[1] 154039662"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_positions[snp_positions > 100000000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of the most common logical operators you will use in R are:\n",
    "\n",
    "\n",
    "```\n",
    "Operator\tDescription\n",
    "<\t        less than\n",
    "<=\t      less than or equal to\n",
    ">\t        greater than\n",
    ">=\t      greater than or equal to\n",
    "==\t      exactly equal to\n",
    "!=\t      not equal to\n",
    "!x\t      not x\n",
    "a | b\t    a or b\n",
    "a & b\t    a and b\n",
    "```\n",
    "\n",
    "\n",
    "Create a Logical vector of snp_positions > 100000000 \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>8762685</li><li>66560624</li><li>67545785</li><li>154039662</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 8762685\n",
       "\\item 66560624\n",
       "\\item 67545785\n",
       "\\item 154039662\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 8762685\n",
       "2. 66560624\n",
       "3. 67545785\n",
       "4. 154039662\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1]   8762685  66560624  67545785 154039662"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>FALSE</li><li>FALSE</li><li>FALSE</li><li>TRUE</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item TRUE\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. FALSE\n",
       "2. FALSE\n",
       "3. FALSE\n",
       "4. TRUE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] FALSE FALSE FALSE  TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_positions\n",
    "snp_positions > 100000000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use function `which()` to get index positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "4"
      ],
      "text/latex": [
       "4"
      ],
      "text/markdown": [
       "4"
      ],
      "text/plain": [
       "[1] 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "which(snp_positions > 100000000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Not Available’ / Missing Values\n",
    "\n",
    "Finally, there are a few other common retrieve or replace operations you may want to know about. \n",
    "\n",
    "First, you can check to see if any of the values of your vector are missing (i.e. are NA). \n",
    "\n",
    "The `is.NA()` function will return a logical vector with TRUE for any NA value:\n",
    "\n",
    "Find NA values value of `snp_genes` vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>'OXTR'</li><li>'ACTN3'</li><li>'AR'</li><li>'OPRM1'</li><li>'CYP1A1'</li><li>NA</li><li>'APOA5'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'OXTR'\n",
       "\\item 'ACTN3'\n",
       "\\item 'AR'\n",
       "\\item 'OPRM1'\n",
       "\\item 'CYP1A1'\n",
       "\\item NA\n",
       "\\item 'APOA5'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'OXTR'\n",
       "2. 'ACTN3'\n",
       "3. 'AR'\n",
       "4. 'OPRM1'\n",
       "5. 'CYP1A1'\n",
       "6. NA\n",
       "7. 'APOA5'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"OXTR\"   \"ACTN3\"  \"AR\"     \"OPRM1\"  \"CYP1A1\" NA       \"APOA5\" "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>FALSE</li><li>FALSE</li><li>FALSE</li><li>FALSE</li><li>FALSE</li><li>TRUE</li><li>FALSE</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item TRUE\n",
       "\\item FALSE\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. FALSE\n",
       "2. FALSE\n",
       "3. FALSE\n",
       "4. FALSE\n",
       "5. FALSE\n",
       "6. TRUE\n",
       "7. FALSE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] FALSE FALSE FALSE FALSE FALSE  TRUE FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_genes\n",
    "#chr [1:7] \"OXTR\" \"ACTN3\" \"AR\" \"OPRM1\" \"CYP1A1\" NA \"APOA5\"\n",
    "is.na(snp_genes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## %in%\n",
    "\n",
    "Sometimes, you may wish to find out if a specific value (or several values) is present a vector. \n",
    "\n",
    "You can do this using the comparison operator `%in%` \n",
    "\n",
    "which will return `TRUE` for any value in your collection that is in the vector you are searching:\n",
    "  \n",
    "Test to see if \"ACTN3\" or \"APO5A\" is in the snp_genes vector.\n",
    "\n",
    "if you are looking for more than one value, you must pass this as a vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>TRUE</li><li>TRUE</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. TRUE\n",
       "2. TRUE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] TRUE TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c(\"ACTN3\",\"APOA5\") %in% snp_genes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Lists are quite useful in R, but we won’t be using them in the genomics lessons. \n",
    "\n",
    "That said, you may come across lists in the way that some bioinformatics programs may store and/or return data to you. \n",
    "\n",
    "One of the key attributes of a list is that, unlike a vector, a list may contain data of more than one mode. \n",
    "\n",
    "In this one example, we will create a named list and show you how to retrieve items from the list.\n",
    "\n",
    "Create a named list using the `list()` function and our SNP examples\n",
    "\n",
    "Note, for easy reading we have placed each item in the list on a separate line\n",
    "\n",
    "Nothing special about this, you can do this for any multiline commands\n",
    "\n",
    "To run this command, make sure the entire command (all 4 lines) are highlighted before running.\n",
    "\n",
    "Note also, as we are doing all this inside the list() function use of the '=' sign is good style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# snp_genes<-c(\"OXTR\", \"ACTN3\", \"AR\", \"OPRM1\")\n",
    "# snps <- c('rs53576', 'rs1815739', 'rs6152', 'rs1799971')\n",
    "# snp_chromosomes <- c('3', '11', 'X', '6')\n",
    "# snp_positions <- c(8762685, 66560624, 67545785, 154039662)\n",
    "\n",
    "snp_data <- list(genes = snp_genes,\n",
    "                 reference_snp = snps,\n",
    "                 chromosome = snp_chromosomes,\n",
    "                 position = snp_positions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List positions by name `$`\n",
    "\n",
    "To get all the values for the position object in the list, we use the `$` notation:\n",
    "\n",
    "Return all the values of position object "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>8762685</li><li>66560624</li><li>67545785</li><li>154039662</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 8762685\n",
       "\\item 66560624\n",
       "\\item 67545785\n",
       "\\item 154039662\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 8762685\n",
       "2. 66560624\n",
       "3. 67545785\n",
       "4. 154039662\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1]   8762685  66560624  67545785 154039662"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "'numeric'"
      ],
      "text/latex": [
       "'numeric'"
      ],
      "text/markdown": [
       "'numeric'"
      ],
      "text/plain": [
       "[1] \"numeric\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_data$position\n",
    "mode(snp_data$position)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the first value in the position object, use the `[]` notation to index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "8762685"
      ],
      "text/latex": [
       "8762685"
      ],
      "text/markdown": [
       "8762685"
      ],
      "text/plain": [
       "[1] 8762685"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snp_data$position[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Key Points\n",
    "\n",
    "* Effectively using R is a journey of months or years. \n",
    "Still you don’t have to be an expert to use R and you can start using and analyzing your data with with about a day’s worth of training\n",
    "\n",
    "* It is important to understand how data are organized by R in a given object type and how the mode of that type (e.g. numeric, character, logical, etc.) will determine how R will operate on that data.\n",
    " \n",
    "* Working with vectors effectively prepares you for understanding how data are organized in R."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R with Stan",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}