Lab_9.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 13 (4/13): Lists, Iteration, and Recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Registered S3 methods overwritten by 'ggplot2':\n",
      "  method         from \n",
      "  [.quosures     rlang\n",
      "  c.quosures     rlang\n",
      "  print.quosures rlang\n",
      "Registered S3 method overwritten by 'rvest':\n",
      "  method            from\n",
      "  read_xml.response xml2\n",
      "-- Attaching packages --------------------------------------- tidyverse 1.2.1 --\n",
      "v ggplot2 3.1.1       v purrr   0.3.2  \n",
      "v tibble  2.1.1       v dplyr   0.8.0.1\n",
      "v tidyr   0.8.3       v stringr 1.4.0  \n",
      "v readr   1.3.1       v forcats 0.4.0  \n",
      "-- Conflicts ------------------------------------------ tidyverse_conflicts() --\n",
      "x dplyr::filter() masks stats::filter()\n",
      "x dplyr::lag()    masks stats::lag()\n",
      "Warning message:\n",
      "\"package 'nycflights13' was built under R version 3.6.3\""
     ]
    }
   ],
   "source": [
    "library(tidyverse)\n",
    "library(nycflights13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectors and Lists\n",
    "\n",
    "**Vectors** are sequences of objects, all of which have the same type. Recall that we can assign these with the `c()` operator:\n",
    "```\n",
    "x = c(1, 2, 3, 4)\n",
    "x = 1:4\n",
    "x = c('a', 'b', 'c')\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "We can also name the entries in a vector either while assigning or by using the `names()` function:\n",
    "```\n",
    "x = c(a=1, b=2, c=3)\n",
    "\n",
    "x = c(1, 2, 3)\n",
    "names(x) = c('a', 'b', 'c')\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lists** are also sequences, but the elements of a list are allowed to be different data types (including vectors or even other lists). Like with vectors, list elements can be named."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$a\n",
      "[1] \"a string\"\n",
      "\n",
      "$b\n",
      "[1] FALSE\n",
      "\n",
      "$c\n",
      "[1] 3.141593\n",
      "\n",
      "$d\n",
      "[1] 1 2 3\n",
      "\n",
      "[1] \"a\" \"b\" \"c\" \"d\"\n"
     ]
    }
   ],
   "source": [
    "x <- list(a='a string', b=FALSE, c=pi, d=1:3)\n",
    "print(x)\n",
    "print(names(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are three ways to subset or extract elements from a list:\n",
    "* `[...]` will extract a sublist. Note that the result of this will always be another list. Integer, logical, or character vectors can be used.\n",
    "* `[[...]]` will extract a single element. Either the index or name of the desired element can be provided.\n",
    "* `$a` will also extract a single element. Note that this requires a named list, and the name must be used. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$a\n",
      "[1] \"a string\"\n",
      "\n",
      "$b\n",
      "[1] FALSE\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(x[1:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$a\n",
      "[1] \"a string\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(x['a'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"a string\"\n"
     ]
    }
   ],
   "source": [
    "print(x[['a']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"a\"\n"
     ]
    }
   ],
   "source": [
    "print(x$a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that dataframes (and tibbles) are basically just lists with some extra features. Here the `names()` correspond to columns, where each element is a vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<caption>A data.frame: 6 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>speed</th><th scope=col>dist</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>1</th><td>4</td><td> 2</td></tr>\n",
       "\t<tr><th scope=row>2</th><td>4</td><td>10</td></tr>\n",
       "\t<tr><th scope=row>3</th><td>7</td><td> 4</td></tr>\n",
       "\t<tr><th scope=row>4</th><td>7</td><td>22</td></tr>\n",
       "\t<tr><th scope=row>5</th><td>8</td><td>16</td></tr>\n",
       "\t<tr><th scope=row>6</th><td>9</td><td>10</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 6 × 2\n",
       "\\begin{tabular}{r|ll}\n",
       "  & speed & dist\\\\\n",
       "  & <dbl> & <dbl>\\\\\n",
       "\\hline\n",
       "\t1 & 4 &  2\\\\\n",
       "\t2 & 4 & 10\\\\\n",
       "\t3 & 7 &  4\\\\\n",
       "\t4 & 7 & 22\\\\\n",
       "\t5 & 8 & 16\\\\\n",
       "\t6 & 9 & 10\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 6 × 2\n",
       "\n",
       "| <!--/--> | speed &lt;dbl&gt; | dist &lt;dbl&gt; |\n",
       "|---|---|---|\n",
       "| 1 | 4 |  2 |\n",
       "| 2 | 4 | 10 |\n",
       "| 3 | 7 |  4 |\n",
       "| 4 | 7 | 22 |\n",
       "| 5 | 8 | 16 |\n",
       "| 6 | 9 | 10 |\n",
       "\n"
      ],
      "text/plain": [
       "  speed dist\n",
       "1 4      2  \n",
       "2 4     10  \n",
       "3 7      4  \n",
       "4 7     22  \n",
       "5 8     16  \n",
       "6 9     10  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head(cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>4</li>\n",
       "\t<li>4</li>\n",
       "\t<li>7</li>\n",
       "\t<li>7</li>\n",
       "\t<li>8</li>\n",
       "\t<li>9</li>\n",
       "\t<li>10</li>\n",
       "\t<li>10</li>\n",
       "\t<li>10</li>\n",
       "\t<li>11</li>\n",
       "\t<li>11</li>\n",
       "\t<li>12</li>\n",
       "\t<li>12</li>\n",
       "\t<li>12</li>\n",
       "\t<li>12</li>\n",
       "\t<li>13</li>\n",
       "\t<li>13</li>\n",
       "\t<li>13</li>\n",
       "\t<li>13</li>\n",
       "\t<li>14</li>\n",
       "\t<li>14</li>\n",
       "\t<li>14</li>\n",
       "\t<li>14</li>\n",
       "\t<li>15</li>\n",
       "\t<li>15</li>\n",
       "\t<li>15</li>\n",
       "\t<li>16</li>\n",
       "\t<li>16</li>\n",
       "\t<li>17</li>\n",
       "\t<li>17</li>\n",
       "\t<li>17</li>\n",
       "\t<li>18</li>\n",
       "\t<li>18</li>\n",
       "\t<li>18</li>\n",
       "\t<li>18</li>\n",
       "\t<li>19</li>\n",
       "\t<li>19</li>\n",
       "\t<li>19</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>22</li>\n",
       "\t<li>23</li>\n",
       "\t<li>24</li>\n",
       "\t<li>24</li>\n",
       "\t<li>24</li>\n",
       "\t<li>24</li>\n",
       "\t<li>25</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 4\n",
       "\\item 4\n",
       "\\item 7\n",
       "\\item 7\n",
       "\\item 8\n",
       "\\item 9\n",
       "\\item 10\n",
       "\\item 10\n",
       "\\item 10\n",
       "\\item 11\n",
       "\\item 11\n",
       "\\item 12\n",
       "\\item 12\n",
       "\\item 12\n",
       "\\item 12\n",
       "\\item 13\n",
       "\\item 13\n",
       "\\item 13\n",
       "\\item 13\n",
       "\\item 14\n",
       "\\item 14\n",
       "\\item 14\n",
       "\\item 14\n",
       "\\item 15\n",
       "\\item 15\n",
       "\\item 15\n",
       "\\item 16\n",
       "\\item 16\n",
       "\\item 17\n",
       "\\item 17\n",
       "\\item 17\n",
       "\\item 18\n",
       "\\item 18\n",
       "\\item 18\n",
       "\\item 18\n",
       "\\item 19\n",
       "\\item 19\n",
       "\\item 19\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 22\n",
       "\\item 23\n",
       "\\item 24\n",
       "\\item 24\n",
       "\\item 24\n",
       "\\item 24\n",
       "\\item 25\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 4\n",
       "2. 4\n",
       "3. 7\n",
       "4. 7\n",
       "5. 8\n",
       "6. 9\n",
       "7. 10\n",
       "8. 10\n",
       "9. 10\n",
       "10. 11\n",
       "11. 11\n",
       "12. 12\n",
       "13. 12\n",
       "14. 12\n",
       "15. 12\n",
       "16. 13\n",
       "17. 13\n",
       "18. 13\n",
       "19. 13\n",
       "20. 14\n",
       "21. 14\n",
       "22. 14\n",
       "23. 14\n",
       "24. 15\n",
       "25. 15\n",
       "26. 15\n",
       "27. 16\n",
       "28. 16\n",
       "29. 17\n",
       "30. 17\n",
       "31. 17\n",
       "32. 18\n",
       "33. 18\n",
       "34. 18\n",
       "35. 18\n",
       "36. 19\n",
       "37. 19\n",
       "38. 19\n",
       "39. 20\n",
       "40. 20\n",
       "41. 20\n",
       "42. 20\n",
       "43. 20\n",
       "44. 22\n",
       "45. 23\n",
       "46. 24\n",
       "47. 24\n",
       "48. 24\n",
       "49. 24\n",
       "50. 25\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       " [1]  4  4  7  7  8  9 10 10 10 11 11 12 12 12 12 13 13 13 13 14 14 14 14 15 15\n",
       "[26] 15 16 16 17 17 17 18 18 18 18 19 19 19 20 20 20 20 20 22 23 24 24 24 24 25"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>4</li>\n",
       "\t<li>4</li>\n",
       "\t<li>7</li>\n",
       "\t<li>7</li>\n",
       "\t<li>8</li>\n",
       "\t<li>9</li>\n",
       "\t<li>10</li>\n",
       "\t<li>10</li>\n",
       "\t<li>10</li>\n",
       "\t<li>11</li>\n",
       "\t<li>11</li>\n",
       "\t<li>12</li>\n",
       "\t<li>12</li>\n",
       "\t<li>12</li>\n",
       "\t<li>12</li>\n",
       "\t<li>13</li>\n",
       "\t<li>13</li>\n",
       "\t<li>13</li>\n",
       "\t<li>13</li>\n",
       "\t<li>14</li>\n",
       "\t<li>14</li>\n",
       "\t<li>14</li>\n",
       "\t<li>14</li>\n",
       "\t<li>15</li>\n",
       "\t<li>15</li>\n",
       "\t<li>15</li>\n",
       "\t<li>16</li>\n",
       "\t<li>16</li>\n",
       "\t<li>17</li>\n",
       "\t<li>17</li>\n",
       "\t<li>17</li>\n",
       "\t<li>18</li>\n",
       "\t<li>18</li>\n",
       "\t<li>18</li>\n",
       "\t<li>18</li>\n",
       "\t<li>19</li>\n",
       "\t<li>19</li>\n",
       "\t<li>19</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>22</li>\n",
       "\t<li>23</li>\n",
       "\t<li>24</li>\n",
       "\t<li>24</li>\n",
       "\t<li>24</li>\n",
       "\t<li>24</li>\n",
       "\t<li>25</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 4\n",
       "\\item 4\n",
       "\\item 7\n",
       "\\item 7\n",
       "\\item 8\n",
       "\\item 9\n",
       "\\item 10\n",
       "\\item 10\n",
       "\\item 10\n",
       "\\item 11\n",
       "\\item 11\n",
       "\\item 12\n",
       "\\item 12\n",
       "\\item 12\n",
       "\\item 12\n",
       "\\item 13\n",
       "\\item 13\n",
       "\\item 13\n",
       "\\item 13\n",
       "\\item 14\n",
       "\\item 14\n",
       "\\item 14\n",
       "\\item 14\n",
       "\\item 15\n",
       "\\item 15\n",
       "\\item 15\n",
       "\\item 16\n",
       "\\item 16\n",
       "\\item 17\n",
       "\\item 17\n",
       "\\item 17\n",
       "\\item 18\n",
       "\\item 18\n",
       "\\item 18\n",
       "\\item 18\n",
       "\\item 19\n",
       "\\item 19\n",
       "\\item 19\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 22\n",
       "\\item 23\n",
       "\\item 24\n",
       "\\item 24\n",
       "\\item 24\n",
       "\\item 24\n",
       "\\item 25\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 4\n",
       "2. 4\n",
       "3. 7\n",
       "4. 7\n",
       "5. 8\n",
       "6. 9\n",
       "7. 10\n",
       "8. 10\n",
       "9. 10\n",
       "10. 11\n",
       "11. 11\n",
       "12. 12\n",
       "13. 12\n",
       "14. 12\n",
       "15. 12\n",
       "16. 13\n",
       "17. 13\n",
       "18. 13\n",
       "19. 13\n",
       "20. 14\n",
       "21. 14\n",
       "22. 14\n",
       "23. 14\n",
       "24. 15\n",
       "25. 15\n",
       "26. 15\n",
       "27. 16\n",
       "28. 16\n",
       "29. 17\n",
       "30. 17\n",
       "31. 17\n",
       "32. 18\n",
       "33. 18\n",
       "34. 18\n",
       "35. 18\n",
       "36. 19\n",
       "37. 19\n",
       "38. 19\n",
       "39. 20\n",
       "40. 20\n",
       "41. 20\n",
       "42. 20\n",
       "43. 20\n",
       "44. 22\n",
       "45. 23\n",
       "46. 24\n",
       "47. 24\n",
       "48. 24\n",
       "49. 24\n",
       "50. 25\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       " [1]  4  4  7  7  8  9 10 10 10 11 11 12 12 12 12 13 13 13 13 14 14 14 14 15 15\n",
       "[26] 15 16 16 17 17 17 18 18 18 18 19 19 19 20 20 20 20 20 22 23 24 24 24 24 25"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>4</li>\n",
       "\t<li>4</li>\n",
       "\t<li>7</li>\n",
       "\t<li>7</li>\n",
       "\t<li>8</li>\n",
       "\t<li>9</li>\n",
       "\t<li>10</li>\n",
       "\t<li>10</li>\n",
       "\t<li>10</li>\n",
       "\t<li>11</li>\n",
       "\t<li>11</li>\n",
       "\t<li>12</li>\n",
       "\t<li>12</li>\n",
       "\t<li>12</li>\n",
       "\t<li>12</li>\n",
       "\t<li>13</li>\n",
       "\t<li>13</li>\n",
       "\t<li>13</li>\n",
       "\t<li>13</li>\n",
       "\t<li>14</li>\n",
       "\t<li>14</li>\n",
       "\t<li>14</li>\n",
       "\t<li>14</li>\n",
       "\t<li>15</li>\n",
       "\t<li>15</li>\n",
       "\t<li>15</li>\n",
       "\t<li>16</li>\n",
       "\t<li>16</li>\n",
       "\t<li>17</li>\n",
       "\t<li>17</li>\n",
       "\t<li>17</li>\n",
       "\t<li>18</li>\n",
       "\t<li>18</li>\n",
       "\t<li>18</li>\n",
       "\t<li>18</li>\n",
       "\t<li>19</li>\n",
       "\t<li>19</li>\n",
       "\t<li>19</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>20</li>\n",
       "\t<li>22</li>\n",
       "\t<li>23</li>\n",
       "\t<li>24</li>\n",
       "\t<li>24</li>\n",
       "\t<li>24</li>\n",
       "\t<li>24</li>\n",
       "\t<li>25</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 4\n",
       "\\item 4\n",
       "\\item 7\n",
       "\\item 7\n",
       "\\item 8\n",
       "\\item 9\n",
       "\\item 10\n",
       "\\item 10\n",
       "\\item 10\n",
       "\\item 11\n",
       "\\item 11\n",
       "\\item 12\n",
       "\\item 12\n",
       "\\item 12\n",
       "\\item 12\n",
       "\\item 13\n",
       "\\item 13\n",
       "\\item 13\n",
       "\\item 13\n",
       "\\item 14\n",
       "\\item 14\n",
       "\\item 14\n",
       "\\item 14\n",
       "\\item 15\n",
       "\\item 15\n",
       "\\item 15\n",
       "\\item 16\n",
       "\\item 16\n",
       "\\item 17\n",
       "\\item 17\n",
       "\\item 17\n",
       "\\item 18\n",
       "\\item 18\n",
       "\\item 18\n",
       "\\item 18\n",
       "\\item 19\n",
       "\\item 19\n",
       "\\item 19\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 20\n",
       "\\item 22\n",
       "\\item 23\n",
       "\\item 24\n",
       "\\item 24\n",
       "\\item 24\n",
       "\\item 24\n",
       "\\item 25\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 4\n",
       "2. 4\n",
       "3. 7\n",
       "4. 7\n",
       "5. 8\n",
       "6. 9\n",
       "7. 10\n",
       "8. 10\n",
       "9. 10\n",
       "10. 11\n",
       "11. 11\n",
       "12. 12\n",
       "13. 12\n",
       "14. 12\n",
       "15. 12\n",
       "16. 13\n",
       "17. 13\n",
       "18. 13\n",
       "19. 13\n",
       "20. 14\n",
       "21. 14\n",
       "22. 14\n",
       "23. 14\n",
       "24. 15\n",
       "25. 15\n",
       "26. 15\n",
       "27. 16\n",
       "28. 16\n",
       "29. 17\n",
       "30. 17\n",
       "31. 17\n",
       "32. 18\n",
       "33. 18\n",
       "34. 18\n",
       "35. 18\n",
       "36. 19\n",
       "37. 19\n",
       "38. 19\n",
       "39. 20\n",
       "40. 20\n",
       "41. 20\n",
       "42. 20\n",
       "43. 20\n",
       "44. 22\n",
       "45. 23\n",
       "46. 24\n",
       "47. 24\n",
       "48. 24\n",
       "49. 24\n",
       "50. 25\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       " [1]  4  4  7  7  8  9 10 10 10 11 11 12 12 12 12 13 13 13 13 14 14 14 14 15 15\n",
       "[26] 15 16 16 17 17 17 18 18 18 18 19 19 19 20 20 20 20 20 22 23 24 24 24 24 25"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cars$speed\n",
    "cars[['speed']]\n",
    "cars[[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "\t<li>4</li>\n",
       "\t<li>5</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\item 4\n",
       "\\item 5\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 1\n",
       "2. 2\n",
       "3. 3\n",
       "4. 4\n",
       "5. 5\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 1 2 3 4 5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "vec1 <- c(1, 2, 3, 4)\n",
    "new_num <- 5\n",
    "\n",
    "append(vec1, new_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "\t<li>4</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\item 4\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 1\n",
       "2. 2\n",
       "3. 3\n",
       "4. 4\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 1 2 3 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "vec1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration\n",
    "\n",
    "The two main ways of iterating in R are `for` and `while` loops.\n",
    "\n",
    "```\n",
    "for (index in vector) {\n",
    "    [do something for each index]\n",
    "}\n",
    "```\n",
    "\n",
    "```\n",
    "while (condition) {\n",
    "    [do something]\n",
    "}\n",
    "```\n",
    "\n",
    "Note that when using a `while` loop it will keep running as long as the condition is `TRUE`, so you want to make certain that eventually whatever you do in the loop will make the condition become `FALSE`, or else it will loop forever.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Calculate 10! (factorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 1\n",
      "[1] 2\n",
      "[1] 6\n",
      "[1] 24\n",
      "[1] 120\n",
      "[1] 720\n",
      "[1] 5040\n",
      "[1] 40320\n",
      "[1] 362880\n",
      "[1] 3628800\n"
     ]
    }
   ],
   "source": [
    "result = 1\n",
    "for (i in 1:10) {\n",
    "    result = result * i\n",
    "    print(result)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 3628800\n"
     ]
    }
   ],
   "source": [
    "result = 1\n",
    "counter = 1\n",
    "while (counter <= 10) {\n",
    "    result = result * counter\n",
    "    counter = counter + 1\n",
    "}\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Note:\n",
    "\n",
    "If you know how many times you want your function to run, it is better to use a for loop. Use a while loop when you are not sure about how many times the code should be running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 131072\n"
     ]
    }
   ],
   "source": [
    "# Highest power of 2 less than 100000\n",
    "curr = 2\n",
    "while (curr <= 100000) {\n",
    "    curr = curr * 2\n",
    "}\n",
    "print(curr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use iteration in functions, with flow control (if / else) and even with other iterators! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "mysum = function(vec) {\n",
    "    result = 0\n",
    "    for (x in vec) {\n",
    "        result = result + x\n",
    "    }\n",
    "    result\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "10"
      ],
      "text/latex": [
       "10"
      ],
      "text/markdown": [
       "10"
      ],
      "text/plain": [
       "[1] 10"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mysum(c(1, 5, 2, 3, 7, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "cumsum = function(vec) {\n",
    "    results = rep(NA, length(vec))\n",
    "    curr = 0\n",
    "    for (ind in 1:length(vec)) {\n",
    "        curr = curr + vec[ind]\n",
    "        results[ind] = curr\n",
    "    }\n",
    "    results\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>6</li>\n",
       "\t<li>8</li>\n",
       "\t<li>11</li>\n",
       "\t<li>18</li>\n",
       "\t<li>23</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 6\n",
       "\\item 8\n",
       "\\item 11\n",
       "\\item 18\n",
       "\\item 23\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 1\n",
       "2. 6\n",
       "3. 8\n",
       "4. 11\n",
       "5. 18\n",
       "6. 23\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1]  1  6  8 11 18 23"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cumsum(c(1, 5, 2, 3, 7, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recursion\n",
    "\n",
    "Recursion is a coding pattern where a function uses itself when doing it's operations. It is usually an alternative to using iteration, and often makes sense to use when a problem can be easily broken down into smaller sub-problems.\n",
    "\n",
    "There are two parts of a good recursive function:\n",
    "1. The base case(s). What are simplest subproblems that have known answers?\n",
    "2. The recursive step. How do you take a bigger problem and break it down into one or more smaller problems.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3628800"
      ],
      "text/latex": [
       "3628800"
      ],
      "text/markdown": [
       "3628800"
      ],
      "text/plain": [
       "[1] 3628800"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "factorial = function(n) {\n",
    "    if (n == 0) return(1)      # base case\n",
    "    \n",
    "    return(n * factorial(n-1))  # recursive step\n",
    "}\n",
    "\n",
    "factorial(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q1: Given a vector `x`, write a function that calculates the sum of the squared odd entries.\n",
    "\n",
    "For example:\n",
    "```\n",
    "f(c(1, 2, 3, 4, 5) == 1^2 + 3^2 + 5^2 == 35\n",
    "f(c(2, 4, 6)) == 0\n",
    "```\n",
    "\n",
    "Reminder that the modulo operator is %% (4 %% 2 = 0, 3 %% 2 = 1, etc)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q2: Use a loop to do the following, storing the result in a vector.\n",
    "\n",
    "1. Compute the mean of every column in `airquality` ignoring missing values.\n",
    "2. Compute the number of unique values in each column of `iris`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "\t<li>4</li>\n",
       "\t<li>5</li>\n",
       "\t<li>6</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\item 4\n",
       "\\item 5\n",
       "\\item 6\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 1\n",
       "2. 2\n",
       "3. 3\n",
       "4. 4\n",
       "5. 5\n",
       "6. 6\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 1 2 3 4 5 6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "seq_along(airquality)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "\t<li>4</li>\n",
       "\t<li>5</li>\n",
       "\t<li>6</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\item 4\n",
       "\\item 5\n",
       "\\item 6\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 1\n",
       "2. 2\n",
       "3. 3\n",
       "4. 4\n",
       "5. 5\n",
       "6. 6\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 1 2 3 4 5 6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "1:ncol(airquality)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>'Ozone'</li>\n",
       "\t<li>'Solar.R'</li>\n",
       "\t<li>'Wind'</li>\n",
       "\t<li>'Temp'</li>\n",
       "\t<li>'Month'</li>\n",
       "\t<li>'Day'</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'Ozone'\n",
       "\\item 'Solar.R'\n",
       "\\item 'Wind'\n",
       "\\item 'Temp'\n",
       "\\item 'Month'\n",
       "\\item 'Day'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'Ozone'\n",
       "2. 'Solar.R'\n",
       "3. 'Wind'\n",
       "4. 'Temp'\n",
       "5. 'Month'\n",
       "6. 'Day'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"Ozone\"   \"Solar.R\" \"Wind\"    \"Temp\"    \"Month\"   \"Day\"    "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "names(airquality)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>42.1293103448276</li>\n",
       "\t<li>185.931506849315</li>\n",
       "\t<li>9.95751633986928</li>\n",
       "\t<li>77.8823529411765</li>\n",
       "\t<li>6.99346405228758</li>\n",
       "\t<li>15.8039215686275</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 42.1293103448276\n",
       "\\item 185.931506849315\n",
       "\\item 9.95751633986928\n",
       "\\item 77.8823529411765\n",
       "\\item 6.99346405228758\n",
       "\\item 15.8039215686275\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 42.1293103448276\n",
       "2. 185.931506849315\n",
       "3. 9.95751633986928\n",
       "4. 77.8823529411765\n",
       "5. 6.99346405228758\n",
       "6. 15.8039215686275\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1]  42.129310 185.931507   9.957516  77.882353   6.993464  15.803922"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Q2.1\n",
    "airquality_mean = rep(NA, ncol(airquality))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>35</li>\n",
       "\t<li>23</li>\n",
       "\t<li>43</li>\n",
       "\t<li>22</li>\n",
       "\t<li>3</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 35\n",
       "\\item 23\n",
       "\\item 43\n",
       "\\item 22\n",
       "\\item 3\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 35\n",
       "2. 23\n",
       "3. 43\n",
       "4. 22\n",
       "5. 3\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 35 23 43 22  3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Q2.2\n",
    "iris_uniq <- rep(NA, ncol(iris))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q3: Recursion\n",
    "\n",
    "The fibonnaci numbers are 0, 1, 1, 2, 3, 5, 8, 13, 21, ...\n",
    "\n",
    "The next number in the sequence is generated by summing the previous two numbers (for n > 2). The first two numbers are fixed at 0, 1. \n",
    "\n",
    "Write a function that can generate the nth fibonacci number. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The downside of loops:\n",
    "\n",
    "They can be very slow. Not really an issue when you have less than say 100,000 iterations, or very simple operations, but a lot of issues can potentially arise when used on larger problems. One way that people tackle this problem, is by implementing other languages such as C++ or Fortran in R. You can do this yourself using the R C++ Package (although you are very much not expected to for this course!). Thankfully, many smart people have written packages with vectorized (takes vectors as arguments and operate on each element of these vectors in another (compiled) language) operations that you can just steal. So the point being is that you really should look for existing solutions first before writing your own loop if its operating on larger data sets. "
   ]
  },
  {
   "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": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}