1 - Introduction and basic data types .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# R - the language\n",
    "\n",
    "\n",
    "R is a programming language and **free software** environment mostly used for statistical computing. https://www.r-project.org/about.html\n",
    "\n",
    "R is high-level programming language, just like Ruby and Python, but more oriented to **tables manipulation** and **statistical analysis**.\n",
    "\n",
    "Please have this **cheatsheet** at hand:\n",
    "http://github.com/rstudio/cheatsheets/raw/master/base-r.pdf\n",
    "\n",
    "If you wanna use R at home (or even during this lesson), you can use **Rstudio**:\n",
    "https://rstudio.com/\n",
    "\n",
    "with the **terminal**, you can instead simply type \"R\".\n",
    "\n",
    "Later in the class, we will use the **ggplot** package to do plotting. ggplot is part of a bigger package, **tidyverse**, which provides many more useful packages https://www.tidyverse.org/\n",
    "\n",
    "\n",
    "You can ge information about a function with the ? character:    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Ciaooo!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have just a vague idea about a function of which you don''t remember the same, you can search it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "??select"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic operations\n",
    "\n",
    "Unlike many programming languages, in R assignment to variable is done with the \"<-\" operator (but you can use also the \"=\" character):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- 3\n",
    "x\n",
    "\n",
    "# wierd enought, you can also do this\n",
    "# 4 -> y\n",
    "# y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aritmetic operations are straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"An addition: 5 + 5 \"\n",
    "5 + 5 \n",
    "\n",
    "\"A subtraction, with a number expressed in scientific notation: 5 - 5e-2\"\n",
    "5 - 5e-2\n",
    "\n",
    "\"Exponentiation: 2^5\"\n",
    "2^5\n",
    "\n",
    "\"Modulo: 28%%6\"\n",
    "28%%6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flow Control\n",
    "\n",
    "R includes all the typical programming elements like IF, FOR , WHILE.....\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in python you use tabs for indentation\n",
    "#if (a < 1):\n",
    "#    print(a)\n",
    "#    x = 10\n",
    "\n",
    "# in R you use brackets\n",
    "height_in_cm <- 195\n",
    "\n",
    "if (height_in_cm > 190) {\n",
    "    print(\"Oooohh you are so tall\")\n",
    "    print(\"Great!\")\n",
    "} else {\n",
    "    print(\"You are ok\")\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i <- 0\n",
    "while (i < 5){\n",
    "    print(paste0(\"i is still less than 5: \", i))\n",
    "    i <- i + 1\n",
    "}\n",
    "print(\"Finally i is 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### FOR loops are quite special, because they iterate over vectors (see later) and use the keyword \"in\":\n",
    "\n",
    "# x is a vector from 1 to 5\n",
    "x <- 1:5\n",
    "\n",
    "\"x is a vector\"\n",
    "x\n",
    "\n",
    "# the variable i will iterate over the vector x, you do not need to increase it manually\n",
    "for (i in x) {\n",
    "    print(paste0(\"i is still less than 5: \", i))\n",
    "    print(i)\n",
    "}\n",
    "\n",
    "print(\"Finally i is 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### next and break \n",
    "\n",
    "When inside a loop (for or while), the special operator **next** force to skip the currect iteration and jump to the next one, while **break** directly exits the loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for (i in 1:10) {\n",
    "    if(i == 4) # don't write 4\n",
    "        next\n",
    "    if(i == 9) # we stop the loop at 9\n",
    "        break\n",
    "    print(i)\n",
    "}\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions can be defined with the **function** keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in Python functions are like this\n",
    "# def func(base, exponent):\n",
    "#   result = base ** exponent\n",
    "#   return(result)\n",
    "\n",
    "func <- function(base, exponent) {\n",
    "    result <- base ^ exponent\n",
    "    return(result)\n",
    "}\n",
    "\n",
    "# call the function\n",
    "func(2, 3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic data types\n",
    "\n",
    "R possesses a few data types: integer, numeric, logical, characters and NA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numeric variable\n",
    "x1 <- 42\n",
    "\n",
    "# A logical variable\n",
    "x2 <- FALSE\n",
    "\n",
    "# A string variable\n",
    "x3 <- \"universe\"\n",
    "\n",
    "# NA means nota available, the data is messing\n",
    "x4 <- NA\n",
    "\n",
    "# Let's see what it's inside x2\n",
    "x2\n",
    "\n",
    "# you can always check a variable type with \"class\"\n",
    "class(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectors\n",
    "\n",
    "Vectors are just an array of elements put into a single variable. <br>\n",
    "In R, *vectors are indexed starting from 1.* <br>\n",
    "The good thing is that R treats them similarly to algebraic vector, so you can do *vectorized* operations, which is a way to avoid loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create vectors using the \"c\" (concatenate) function\n",
    "numbers <- c(1, 2, 10, 6, 49, 101, 155, 8)\n",
    "characters <- c(\"a\", \"b\", \"c\")\n",
    "# the colon operator creates interger sequences (also check out the seq() function )\n",
    "sequence <- 1:10\n",
    "\n",
    "numbers\n",
    "characters\n",
    "sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- 20:30\n",
    "x\n",
    "\n",
    "\"The fourth element\"\n",
    "x[4] \n",
    "\n",
    "\"All but the fourth\"\n",
    "x[-4] \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing vectors with another vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- 20:30\n",
    "\n",
    "\"Use a vector to index another vector\"\n",
    "x[c(1, 2, 8)] \n",
    "\n",
    "\"Elements two to four\"\n",
    "x[2:4] \n",
    "\n",
    "\"All Elements except one and five.\"\n",
    "x[-c(1, 5)] \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vector names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- 1:10\n",
    "\"The vector without names\"\n",
    "x\n",
    "\n",
    "# You can give names to the vector elements\"\n",
    "names(x) <- c(\"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\", \"Ten\")\n",
    "\n",
    "\"The vector with names\"\n",
    "x\n",
    "\n",
    "\"Only the names (which is a vector itself)\"\n",
    "names(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NA \n",
    "\n",
    "NA simply indicates that the value is missing, and it is a type for itself. Be careful that doing operations of NAs may return a NA!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a vector containing a missing value\n",
    "vec <- c(1, 2, 3, NA, 5)\n",
    "\n",
    "\" if we take the mean of the vector, we get a NA\"\n",
    "mean(vec)\n",
    "\n",
    "\" which can be avoided by ignoring the NAs\"\n",
    "mean(vec, na.rm=T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example: plotting\n",
    "\n",
    "plot() is the basic R function for plotting. The resulting plot depends on the data you provide, but in general is a scatterplot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- 1:10\n",
    "y <- c(12, 25, 11, 3, 24, 30, 12, 34, 10, 6)\n",
    "\n",
    "plot(x, y)\n",
    "barplot(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectorization\n",
    "\n",
    "As noted before R automatically **vectorize** operations that involve vectors and non-vectors (another way to avoid loops)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- 1:10\n",
    "\n",
    "\"Elements positions which are equal to 10.\"\n",
    "x == 10\n",
    "\n",
    "\"Elements which are equal to 10.\"\n",
    "x[x == 10] \n",
    "\n",
    "\"All elements less than 10\"\n",
    "x[x < 10] \n",
    "\n",
    "\"Elements in the set 1, 2, 5.\"\n",
    "x[x %in% c(1, 2, 5)]\n",
    "\n",
    "\n",
    "\"Elements not it the set 1, 2, 5.\"\n",
    "x[!x %in% c(1, 2, 5)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This seems a little counterintuitive (some other languages do not possess this property), but it is very useful. For example, you can modify a vector (and also other higher datatypes) in *one shot*:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- 1:10\n",
    "\n",
    "\"Print x\"\n",
    "x\n",
    "\n",
    "\"Print the elements lower than 5\"\n",
    "x[x < 5]\n",
    "\n",
    "\"Set the elements lower than 5 to zero\"\n",
    "x[x < 5] <- 0\n",
    "\n",
    "x\n",
    "\n",
    "\"Turn the vector elements into percentages, and round them to 2 decimal points\"\n",
    "x / sum(x) * 100\n",
    "round(x / sum(x) * 100, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic plotting\n",
    "\n",
    "Vectorization can be extremely useful for plotting. In this example we are going to simulate a linear regression, and show how you can out several plot in the same page with the \"par()\" function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulate the height of 100 people\n",
    "height <- rnorm(n = 100, mean = 175, sd = 10)\n",
    "hist(height)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imagine that the weight = height * 0.4\n",
    "weight <- 10 + height * 0.4\n",
    "hist(weight)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot weight against height\n",
    "plot(height, weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add some variability (noise)\n",
    "weight <- weight + rnorm(100, 0, 1)\n",
    "plot(height, weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# the function lm simply perform a linear regressin with the formula y ~ x\n",
    "fit <- lm(weight ~ height) \n",
    "\"Have a look at the linear regression\"\n",
    "fit\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's prepare a 2 by 2 plot\n",
    "par(mfrow = c(2,2))\n",
    "# plot the histograms of height and weight\n",
    "hist(height)\n",
    "hist(weight)\n",
    "# plot the relationship between height and weight\n",
    "plot(x = height, y = weight)\n",
    "# plot again the relationship, and add the regression line\n",
    "plot(x = height, y = weight)\n",
    "abline(fit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix\n",
    "\n",
    "Matrices are just 2-dimensional vector, nothing special really.....They are a collection of elements of the same data type (numeric, character, or logical) arranged into a fixed number of rows and columns. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are several way to create a matrix, one is to turn a vector into a matrix\n",
    "x <- 1:9\n",
    "m <- matrix(x, nrow = 3, ncol = 3)\n",
    "\n",
    "\"Print the matrix\"\n",
    "m\n",
    "\n",
    "# by default elements are entered into the matrix by column, but you can do it by row\n",
    "m <- matrix(x, nrow = 3, ncol = 3, byrow = T)\n",
    "\n",
    "\"Print the matrix by row\"\n",
    "m\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subsetting matrices\n",
    "\n",
    "matrices can be easily subsetted by their indices. \\\\\n",
    "*Warning: selecting only one row or column automatically returns a vector, which can produce later undesired results. use drop=F to avoid this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- 1:9\n",
    "m <- matrix(x, nrow = 3, ncol = 3, byrow = T)\n",
    "m\n",
    "\n",
    "\"Get the element in position 1, 2\"\n",
    "m[1, 2]\n",
    "\n",
    "\"Get the the second and third column\"\n",
    "m[, 2:3]\n",
    "\n",
    "\n",
    "\"Get the first row (be careful, the result is a vector, use drop=F to avoid it)\"\n",
    "m[1, ]\n",
    "m[1,,drop=F]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix algebra operations\n",
    "\n",
    "Matrices can be used to do any kind of algebraic operation.\n",
    "\n",
    "check more at: https://www.statmethods.net/advstats/matrix.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m\n",
    "\n",
    "\"Matrix multiplication\"\n",
    "m %*% m\n",
    "\n",
    "\"transpose\"\n",
    "t(m)\n",
    "\n",
    "\"Determinant\"\n",
    "det(m)\n",
    "\n",
    "\"Sum of the rows\"\n",
    "rowSums(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Columns and rows names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rownames(m) <- c(\"one\", \"two\", \"three\")\n",
    "colnames(m) <- c(\"uno\", \"dos\", \"tres\")\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulating matrices\n",
    "\n",
    "You can add rows and columns with rbind() and cbind()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Add a row\"\n",
    "rbind(m, c(10, 10, 10))\n",
    "\n",
    "\"Add a column\"\n",
    "cbind(m, c(10, 10, 10))\n",
    "\n",
    "\"join two matrices by rows\"\n",
    "rbind(m, m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "List are like vector but they can **contain elements of different types**. <br>\n",
    "A list can be used to store for example a person's features (height, weight, name, birth date....), which are of different types.<br>\n",
    "Of course lists cannot be used for algebraic operations like vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pepe <- list(Name = \"Pepe\", Height = 180, Birth=as.Date(\"05/05/1955\"), Pets=c(\"gato1\", \"gato2\", \"perro1\" )) \n",
    "\n",
    "pepe\n",
    "\n",
    "# List can be indexed by the dollar symbol $\n",
    "\"Pepes pets, by dollar\"\n",
    "pepe$Pets\n",
    "\n",
    "# Or if the element does not have a name, by index using double [[]]\n",
    "\"Pepes pets, by index\"\n",
    "pepe[[4]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The apply functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A popular alternative to loops in R are the apply functions:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits <- list(\"mangoes\", \"bananas\", \"peaches\",\"oranges\", \"apples\")\n",
    "\n",
    "\"How long is each word? we can use a loop\"\n",
    "l <- c()\n",
    "for(x in fruits)\n",
    "    l <- c(l, nchar(x))\n",
    "l\n",
    "    \n",
    "\"sapply applies the nchar function on each element and returns a list\"\n",
    "l <- sapply(fruits, nchar)\n",
    "l\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### apply's anonymous function\n",
    "\n",
    "if the function to apply is more complex, you can specify it directly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits <- list(\"mangoes\", \"bananas\", \"peaches\",\"oranges\", \"apples\")\n",
    "\n",
    "\"check which words are of 7 characters\"\n",
    "sapply(fruits, function(x) if(nchar(x) == 7) return (T) else return (F) )\n",
    "    \n",
    "# The previous function is \"anonymous\", because it is only visible inside the apply function.\n",
    "# But you can specify an external function, especially if is very long\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*warning: if sapply cannot simplify the result into a vector, it will return a list just l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### the apply family"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- apply iterates over rows or columns of matrices\n",
    "- lapply iterates over list and vector, apply a specific functions for each element and returns a list of results\n",
    "- sapply is similar to lapply but tries to compress the result into a vector. If used wrongly can return wierd results\n",
    "- vapply only iterates over vectors and requires to specify the type of return value. It can be safer and faster than sapply\n",
    "- rapply recursively iterate over nested lists: list(..., list(list(), list()...)...)\n",
    "- mapply apply a function for each element of same-length vectors: mapply(sum, 1:3, 1:3, 1:3) -> 3 6 9\n",
    "- tapply apply a function based on grouping define by a factor (see next section)\n",
    "\n",
    "For more informations: https://ademos.people.uic.edu/Chapter4.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Factors\n",
    "\n",
    "Factor a categorical variables. They can be very useful when we want to group together elements of vectors, lists data frames....\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# a normal vector\n",
    "fruits <- c(\"apple\", \"apple\", \"orange\", \"orange\", \"apple\")\n",
    "\n",
    "# create a vector out of it\n",
    "fruits_factor <- factor(fruits)\n",
    "\n",
    "\"the vector\"\n",
    "fruits\n",
    "\"the factor\"\n",
    "fruits_factor\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "notice the difference, \"fruits\" is just a vector of strings, \"fruits_factor\" is a factor, a vector of categories. \"Levels\" shows you the categories contained in the factor.\n",
    "The second factor has been created from a vector of numbers, as you can see, R created a factor of categories as with the fruit vector. *It does not matter what type is used to create a factor, equal element will correspond to a single category*\n",
    "\n",
    "\n",
    "Why do we need factors? \n",
    "Factors are needed to tell R which elements belongs to the same group. For example, let's see the **tapply** function:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's say we have 5 fruits....\n",
    "\n",
    "# the vector of fruit types\n",
    "fruits <- c(\"apple\", \"apple\", \"pineapple\", \"orange\", \"pineapple\")\n",
    "\n",
    "# the size of each fruit\n",
    "sizes <- c(2, 3, 15, 4, 18)\n",
    "\n",
    "# How can we get the average of each TYPE of fruit?\n",
    "# tapply get the mean for each group!\n",
    "tapply(X = sizes, INDEX = factor(fruits), FUN = mean)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: The Monty Hall problem\n",
    "\n",
    "<img src=\"montyhallproblem.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The monty hall problem is loosely based on the American television game show from the '60s. The contestant is presented with 3 doors: one contains a valuable car, and the other two hid goats. The contestant has to choose a door and try to win the prize. However:\n",
    "\n",
    "- after choosing a door, the door is not inmediately revealed\n",
    "- the host will instead open one of the two remeaining doors, **always** revealing a goat (the host knows what is behind each door)\n",
    "- the contestant is therefore left with two remaining doors, the chosen one and the alternative\n",
    "- the contestant is offered the choice to keep the original door or to switch to the alternative\n",
    "\n",
    "What do you think is the best option for the contestant?  to stay or to switch? Or is does not matter? *(hint: think of a similar game but with MANY doors, one cars a many goats)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try to solve the problem by simulation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iterations\n",
    "N <- 100\n",
    "\n",
    "# Solution with for loop\n",
    "doors <- c(\"A\", \"B\", \"C\")\n",
    "car <- vector(\"integer\", N)  # the doors hiding the cars\n",
    "choice <- vector(\"integer\", N) # the doors chosen by the participant\n",
    "monty <- vector(\"integer\", N) # the doors revealed by monty\n",
    "closed <- vector(\"integer\", N) # the doors that is not either the choice or monty's\n",
    "win_stay <- vector(\"logical\", N)  # the times that we win by staying\n",
    "win_switch <- vector(\"logical\", N) # the times that we win by switching\n",
    "for(i in 1:N) {\n",
    "  car[i] <- sample(x = doors, size = 1)\n",
    "  choice[i] <- sample(x = doors, size = 1)\n",
    "  monty[i] <- sample(x = doors[!doors %in% c(choice[i], car[i])], size = 1)\n",
    "  closed[i] <- doors[!doors %in% c(choice[i], monty[i])]\n",
    "  win_stay[i] <- car[i] == choice[i]\n",
    "  win_switch[i] <- car[i] == closed[i]\n",
    "}\n",
    "\n",
    "\n",
    "table(win_stay)\n",
    "table(win_switch)\n",
    "\n",
    "res <- cbind(cumsum(win_stay), cumsum(win_switch))\n",
    "colnames(res) <- c(\"Stay\", \"Switch\")\n",
    "head(res)\n",
    "matplot(y = res, col=c(\"red\", \"blue\"), pch=16, ylab=\"Number of wins\", xlab=\"Iteration\", cex=2, cex.axis=2,  cex.lab=2)\n",
    "legend(x = 10, y = 60, c(\"Stay\", \"Switch\"),  col=c(\"red\", \"blue\"), pch = 16, cex=2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution with vectorizations functions\n",
    "doors <- c(\"A\", \"B\", \"C\")\n",
    "car <- sample(x = doors, size = N, replace = T)\n",
    "choice <- sample(x = doors, size = N, replace = T)\n",
    "monty <- sapply(1:N, function(i) sample(x = doors[!doors %in% c(choice[i], car[i])], size = 1))\n",
    "closed <- sapply(1:N, function(i) doors[!doors %in% c(choice[i], monty[i])])\n",
    "win_stay <- car == choice\n",
    "win_switch <- car == closed"
   ]
  }
 ],
 "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.0.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}