R/clases/1_introduccion/1_informacion_general.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notas para contenedor de docker:**\n",
    "\n",
    "Comando de docker para ejecución de la nota de forma local:\n",
    "\n",
    "nota: cambiar `dir_montar` por la ruta de directorio que se desea mapear a `/datos` dentro del contenedor de docker.\n",
    "\n",
    "```\n",
    "dir_montar=<ruta completa de mi máquina a mi directorio>#aquí colocar la ruta al directorio a montar, por ejemplo: \n",
    "#dir_montar=/Users/erick/midirectorio.\n",
    "```\n",
    "\n",
    "Ejecutar:\n",
    "\n",
    "```\n",
    "VERSION=<versión imagen de docker>\n",
    "docker run --rm -v $dir_montar:/datos --name jupyterlab_prope_r_kernel_tidyverse -p 8888:8888 -d palmoreck/jupyterlab_prope_r_kernel_tidyverse:$VERSION\n",
    "\n",
    "```\n",
    "\n",
    "Ir a `localhost:8888` y escribir el password para jupyterlab: `qwerty`\n",
    "\n",
    "\n",
    "Detener el contenedor de docker:\n",
    "\n",
    "```\n",
    "docker stop jupyterlab_prope_r_kernel_tidyverse\n",
    "```\n",
    "\n",
    "Documentación de la imagen de docker `palmoreck/jupyterlab_prope_r_kernel_tidyverse:<versión imagen de docker>` en [liga](https://github.com/palmoreck/dockerfiles/tree/master/jupyterlab/prope_r_kernel_tidyverse)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecución de la nota usar:\n",
    "\n",
    "[docker](https://www.docker.com/) (instalación de forma **local** con [Get docker](https://docs.docker.com/install/)) y ejecutar comandos que están al inicio de la nota de forma **local**. \n",
    "\n",
    "O bien dar click en alguno de los botones siguientes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/palmoreck/dockerfiles-for-binder/jupyterlab_prope_r_kernel_tidyverse?urlpath=lab/tree/Propedeutico/R/clases/1_introduccion/1_informacion_general.ipynb) esta opción crea una máquina individual en un servidor de Google, clona el repositorio y permite la ejecución de los notebooks de jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Run on Repl.it](https://repl.it/badge/github/palmoreck/dummy)](https://repl.it/languages/Rlang) esta opción no clona el repositorio, no ejecuta los notebooks de jupyter pero permite ejecución de instrucciones de Python de forma colaborativa con [repl.it](https://repl.it/). Al dar click se crearán nuevos ***repl*** debajo de sus users de ***repl.it***.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lo siguiente está basado en:\n",
    "\n",
    "### * [R: Un lenguaje para análisis de datos por E. B. Zamudio](http://allman.rhon.itam.mx/~ebarrios/docs/porqueR.pdf)\n",
    "\n",
    "### * El prefacio y capítulo 1 de M.D. Ugarte, A. F. Militino, A. T. Arnholt, Probability and Statistics with R, **2ed** (que tiene github: [alanarnholt/PASWR2E-Book](https://github.com/alanarnholt/PASWR2E-Book))\n",
    "\n",
    "### * [R-intro](https://cran.r-project.org/doc/manuals/R-intro.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Información general"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Qué es?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*R* es un lenguaje de programación basado en *S* el cual es un lenguaje y un ambiente de programación interactiva para el análisis de datos y graficación desarrollado por los *Bell laboratories* por Rick Becker, John Chambers y Allan Wilks. Dos implementaciones del lenguaje *S* existen: *R* una implementación **open source** disponible en [r-project](http://www.r-project.org) y [S-PLUS](https://en.wikipedia.org/wiki/S-PLUS) una implementación comercial. *R* es el resultado de esfuerzos de todo el mundo y fue escrito inicialmente por Robert Gentleman y Ross Ihaka del departamento de Estadística de la Universidad de Auckland en 1996."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*R* es un lenguaje y ambiente para cómputo estadístico y graficación. El término ambiente lo caracteriza como un sistema completamente planeado y coherente en el que técnicas estadísticas clásicas y modernas han sido implementadas. Algunas forman parte de *R* las llamadas *built-in* pero otras se proveen vía paquetes. Alrededor de 25 paquetes son incluídas con la instalación de *R* (*standard* & *recommended*) y muchas más se encuentran disponibles en [CRAN family of Internet sites: Contributed Packages](https://cran.r-project.org/web/packages/index.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Qué provee?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El ambiente de *R* contiene software que permite la manipulación de datos, cálculos y visualización de gráficos y tiene:\n",
    "\n",
    "* programas para almacenamiento y manejo de datos.\n",
    "* una gama amplia de operadores para cálculos en arreglos, en particular matrices.\n",
    "* una gran colección de herramientas intermedias correctamente integradas para análisis de datos.\n",
    "* lenguaje de programación *S* para *loops*, funciones definidas por *users* y desarrollo para I/O.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*R* es un vehículo para desarrollo de nuevos métodos de análisis de datos de forma interactiva y se extiende por medio de paquetes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Diferencia entre *S* (y por tanto *R*) y otros softwares de Estadística?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(extraído de [R-intro: 1.3 R and statistics](https://cran.r-project.org/doc/manuals/R-intro.html)) \"There is an important difference in philosophy between S (and hence R) and the other main statistical systems. In S a statistical analysis is normally done as a series of steps, with intermediate results being stored in objects. Thus whereas SAS and SPSS will give copious output from a regression or discriminant analysis, R will give minimal output and store the results in a fit object for subsequent interrogation by further R functions.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Características de *S* "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(extraído de [R: Un lenguaje para análisis de datos por E. B. Zamudio](http://allman.rhon.itam.mx/~ebarrios/docs/porqueR.pdf))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* *S* es sobre datos: provee de herramientas generales y fáciles de usar para la organización, almacenamiento y recuperación de varios tipos de datos.\n",
    "\n",
    "* *S* es sobre análisis: es decir, cálculos necesarios para entender los datos. *S* provee de métodos numéricos y otras técnicas computacionales.\n",
    "\n",
    "* *S* es sobre programación: usted puede programar funciones en el mismo lenguaje *S* aprovechando su poder y simplicidad. Si es necesario el lenguaje ofrece  interfaces  para  comunicación  con  el  sistema  operativo  o rutinas en *C* y *Fortran*.\n",
    "\n",
    "* Especialmente, *S* es sobre graficación: ver a los datos de maneras interactivas, informativas y flexibles. Las capacidades de *S* están diseñadas para motivar la creación de nuevas herramientas e intentar nuevas ideas.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Ambientes comunes para ejecución de *R*?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* *jupyter notebooks*\n",
    "\n",
    "* [Rstudio](https://rstudio.com/)\n",
    "\n",
    "* [Rocker](https://github.com/rocker-org/rocker)\n",
    "\n",
    "```\n",
    "dir_montar=<ruta completa de mi máquina a mi directorio>#aquí colocar la ruta al directorio a montar, por ejemplo: \n",
    "#dir_montar=/Users/erick/midirectorio.\n",
    "\n",
    "PASSWORD=qwerty\n",
    "\n",
    "\n",
    "docker run --rm -d -p 8787:8787 -v $dir_montar:/home/rstudio/ --name rstudio-container -e PASSWORD=$PASSWORD rocker/rstudio:4.1.1\n",
    "```\n",
    "\n",
    "User: `rstudio` y password: `qwerty`. Ir a `localhost:8787`\n",
    "\n",
    "Ver https://hub.docker.com/r/rocker/rstudio/tags para los tags que existen (en el caso anterior se usa `rocker/rstudio:4.1.1`)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calcular la probabilidad de obtener sol al lanzar una moneda vía simulación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solución** \n",
    "\n",
    "Para este caso simulamos $1000$ lanzamientos con la función [sample](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/sample) que se encuentra en el paquete [base](https://stat.ethz.ch/R-manual/R-devel/library/base/html/00Index.html) de *R*. Al final del ejemplo se muestra cómo acceder a su descripción y la misma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo si queremos simular un resultado de lanzamiento lo ejecutamos como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'aguila'"
      ],
      "text/latex": [
       "'aguila'"
      ],
      "text/markdown": [
       "'aguila'"
      ],
      "text/plain": [
       "[1] \"aguila\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "set.seed(2000) #for reproducibility\n",
    "sample(c(\"aguila\", \"sol\"), 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos simular tres resultados de lanzamientos realizamos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>'aguila'</li><li>'sol'</li><li>'sol'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'aguila'\n",
       "\\item 'sol'\n",
       "\\item 'sol'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'aguila'\n",
       "2. 'sol'\n",
       "3. 'sol'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"aguila\" \"sol\"    \"sol\"   "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "set.seed(2000)\n",
    "sample(c('aguila', 'sol'), 3, replace=T) #with replacement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creamos una función con la palabra `function` que recibe el número de lanzamientos a realizar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "throw_coin <- function(number_of_throwings){\n",
    "                  set.seed(1989) #1989 randomly choosen\n",
    "                  sample(c('aguila', 'sol'),number_of_throwings,replace=T)\n",
    "              }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación** \n",
    "\n",
    "Obsérvese que se ha utilizado el operador de asignación `<-`. También es posible utilizar `=` pero se prefiere `<-` para legibilidad de código.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo 4 lanzamientos se realizan con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>'sol'</li><li>'aguila'</li><li>'sol'</li><li>'aguila'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'sol'\n",
       "\\item 'aguila'\n",
       "\\item 'sol'\n",
       "\\item 'aguila'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'sol'\n",
       "2. 'aguila'\n",
       "3. 'sol'\n",
       "4. 'aguila'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"sol\"    \"aguila\" \"sol\"    \"aguila\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "throw_coin(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8 lanzamientos con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>'sol'</li><li>'aguila'</li><li>'sol'</li><li>'aguila'</li><li>'aguila'</li><li>'aguila'</li><li>'aguila'</li><li>'sol'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'sol'\n",
       "\\item 'aguila'\n",
       "\\item 'sol'\n",
       "\\item 'aguila'\n",
       "\\item 'aguila'\n",
       "\\item 'aguila'\n",
       "\\item 'aguila'\n",
       "\\item 'sol'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'sol'\n",
       "2. 'aguila'\n",
       "3. 'sol'\n",
       "4. 'aguila'\n",
       "5. 'aguila'\n",
       "6. 'aguila'\n",
       "7. 'aguila'\n",
       "8. 'sol'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"sol\"    \"aguila\" \"sol\"    \"aguila\" \"aguila\" \"aguila\" \"aguila\" \"sol\"   "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "throw_coin(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entonces nuestra simulación de lanzamientos se ejecuta como sigue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "0.497"
      ],
      "text/latex": [
       "0.497"
      ],
      "text/markdown": [
       "0.497"
      ],
      "text/plain": [
       "[1] 0.497"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_tosses <- 1000\n",
    "sum(throw_coin(num_tosses)==\"sol\")/num_tosses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "el cual es un valor cercano a la respuesta $0.5$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y obsérvese que con un número menor de lanzamientos nuestra estimación no es buena:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "0.3"
      ],
      "text/latex": [
       "0.3"
      ],
      "text/markdown": [
       "0.3"
      ],
      "text/plain": [
       "[1] 0.3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_tosses <- 10\n",
    "sum(throw_coin(num_tosses)==\"sol\")/num_tosses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Y si quisiéramos usar un paquete para este ejemplo? ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un paquete es una colección de funciones de *R*, datos (*datasets*) y código compilado que tienen una organización uniforme."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden instalar con la línea `install.packages(\"<aquí colocar el nombre del paquete>\", dependencies=TRUE)` que utiliza por default el repositorio [The Comprehensive R Archive Network: CRAN](https://cran.r-project.org/) (pero hay otros repositorios como: [Bioconductor](https://www.bioconductor.org/), [Omegahat](http://www.omegahat.net/) o [R-Forge](http://r-forge.r-project.org/))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación** \n",
    "\n",
    "Un paquete sólo se instala una vez excepto si se tiene una nueva versión de *R*.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Para instalar paquetes en los jupyter notebooks...?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar en una celda: \n",
    "\n",
    "```\n",
    "install.packages(\"<aquí colocar el nombre del paquete>\",lib=\"/usr/local/lib/R/site-library/\",\n",
    "                repos=\"https://cran.itam.mx/\",verbose=TRUE)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo de paquete que ya está en la imagen de docker instalado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la imagen de *docker* `palmoreck/jupyterlab_prope_r_kernel_tidyverse:<versión imagen de docker>` cuya documentación está en [liga](https://github.com/palmoreck/dockerfiles/tree/master/jupyterlab/prope_r_kernel_tidyverse) se tienen paquetes ya instalados que utilizaremos en el curso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El paquete `prob` es un *framework* para calcular probabilidades de experimentos sencillos (finitos) y generar las posibilidades de resultados. Ver: [Package prob](https://cran.r-project.org/web/packages/prob/prob.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una vez instalado el paquete se debe hacer disponibles todos los contenidos del paquete en el ambiente de trabajo, esto es, se debe cargar (*load a package*). Para lo anterior tenemos a la función `library`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Comentario** \n",
    "\n",
    "Si se ejecuta la función library sin argumentos: `library()` se enlistan todos los paquetes instalados.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading required package: combinat\n",
      "\n",
      "\n",
      "Attaching package: ‘combinat’\n",
      "\n",
      "\n",
      "The following object is masked from ‘package:utils’:\n",
      "\n",
      "    combn\n",
      "\n",
      "\n",
      "Loading required package: fAsianOptions\n",
      "\n",
      "Loading required package: timeDate\n",
      "\n",
      "Loading required package: timeSeries\n",
      "\n",
      "Loading required package: fBasics\n",
      "\n",
      "Loading required package: fOptions\n",
      "\n",
      "\n",
      "Attaching package: ‘prob’\n",
      "\n",
      "\n",
      "The following objects are masked from ‘package:base’:\n",
      "\n",
      "    intersect, setdiff, union\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "library(prob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación** \n",
    "\n",
    "Obsérvese que al ejecutar `library` el output indica que está ennmascarados algunos objetos como `union`. Esto indica que en `prob` existe un objeto con nombre `union` y también en `base` existe el mismo nombre de `union`. Para ejecutar una u otra función se puede: usar una sintaxis de la forma `base::union` para uso de la función `union` del paquete `base` o bien `prob::union` para uso de la función `union` del paquete `prob` aunque también **muchas de las funciones se *comportan* de forma distinta dependiendo del tipo de argumentos que reciben**. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usamos la función find para observar el enmascaramiento antes descrito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>'package:prob'</li><li>'package:base'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'package:prob'\n",
       "\\item 'package:base'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'package:prob'\n",
       "2. 'package:base'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"package:prob\" \"package:base\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "find(\"union\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se utiliza la función [tosscoin](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/tosscoin) para resolver el problema y se puede acceder a los argumentos de la misma con la función `args`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=language-r><code>function (times, makespace = FALSE) \n",
       "NULL</code></pre>"
      ],
      "text/latex": [
       "\\begin{minted}{r}\n",
       "function (times, makespace = FALSE) \n",
       "NULL\n",
       "\\end{minted}"
      ],
      "text/markdown": [
       "```r\n",
       "function (times, makespace = FALSE) \n",
       "NULL\n",
       "```"
      ],
      "text/plain": [
       "function (times, makespace = FALSE) \n",
       "NULL"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "args(tosscoin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1 lanzamiento de una moneda, dos posibilidades**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 2 × 1</caption>\n",
       "<thead>\n",
       "\t<tr><th scope=col>toss1</th></tr>\n",
       "\t<tr><th scope=col>&lt;fct&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><td>H</td></tr>\n",
       "\t<tr><td>T</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 2 × 1\n",
       "\\begin{tabular}{l}\n",
       " toss1\\\\\n",
       " <fct>\\\\\n",
       "\\hline\n",
       "\t H\\\\\n",
       "\t T\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 2 × 1\n",
       "\n",
       "| toss1 &lt;fct&gt; |\n",
       "|---|\n",
       "| H |\n",
       "| T |\n",
       "\n"
      ],
      "text/plain": [
       "  toss1\n",
       "1 H    \n",
       "2 T    "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tosscoin(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1 lanzamiento de una moneda, dos posibilidades y probabilidad de .5**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 2 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th scope=col>toss1</th><th scope=col>probs</th></tr>\n",
       "\t<tr><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;dbl&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><td>H</td><td>0.5</td></tr>\n",
       "\t<tr><td>T</td><td>0.5</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 2 × 2\n",
       "\\begin{tabular}{ll}\n",
       " toss1 & probs\\\\\n",
       " <fct> & <dbl>\\\\\n",
       "\\hline\n",
       "\t H & 0.5\\\\\n",
       "\t T & 0.5\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 2 × 2\n",
       "\n",
       "| toss1 &lt;fct&gt; | probs &lt;dbl&gt; |\n",
       "|---|---|\n",
       "| H | 0.5 |\n",
       "| T | 0.5 |\n",
       "\n"
      ],
      "text/plain": [
       "  toss1 probs\n",
       "1 H     0.5  \n",
       "2 T     0.5  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tosscoin(1, makespace = T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lanzamiento de tres monedas distintas o bien, lanzamiento de una moneda tres veces, 8 posibilidades y probabilidad de 1/8**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A manera de ejemplo de uso de esta función, se muestra cómo se puede realizar diferentes cálculos de probabilidades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 8 × 4</caption>\n",
       "<thead>\n",
       "\t<tr><th scope=col>toss1</th><th scope=col>toss2</th><th scope=col>toss3</th><th scope=col>probs</th></tr>\n",
       "\t<tr><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;dbl&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><td>H</td><td>H</td><td>H</td><td>0.125</td></tr>\n",
       "\t<tr><td>T</td><td>H</td><td>H</td><td>0.125</td></tr>\n",
       "\t<tr><td>H</td><td>T</td><td>H</td><td>0.125</td></tr>\n",
       "\t<tr><td>T</td><td>T</td><td>H</td><td>0.125</td></tr>\n",
       "\t<tr><td>H</td><td>H</td><td>T</td><td>0.125</td></tr>\n",
       "\t<tr><td>T</td><td>H</td><td>T</td><td>0.125</td></tr>\n",
       "\t<tr><td>H</td><td>T</td><td>T</td><td>0.125</td></tr>\n",
       "\t<tr><td>T</td><td>T</td><td>T</td><td>0.125</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 8 × 4\n",
       "\\begin{tabular}{llll}\n",
       " toss1 & toss2 & toss3 & probs\\\\\n",
       " <fct> & <fct> & <fct> & <dbl>\\\\\n",
       "\\hline\n",
       "\t H & H & H & 0.125\\\\\n",
       "\t T & H & H & 0.125\\\\\n",
       "\t H & T & H & 0.125\\\\\n",
       "\t T & T & H & 0.125\\\\\n",
       "\t H & H & T & 0.125\\\\\n",
       "\t T & H & T & 0.125\\\\\n",
       "\t H & T & T & 0.125\\\\\n",
       "\t T & T & T & 0.125\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 8 × 4\n",
       "\n",
       "| toss1 &lt;fct&gt; | toss2 &lt;fct&gt; | toss3 &lt;fct&gt; | probs &lt;dbl&gt; |\n",
       "|---|---|---|---|\n",
       "| H | H | H | 0.125 |\n",
       "| T | H | H | 0.125 |\n",
       "| H | T | H | 0.125 |\n",
       "| T | T | H | 0.125 |\n",
       "| H | H | T | 0.125 |\n",
       "| T | H | T | 0.125 |\n",
       "| H | T | T | 0.125 |\n",
       "| T | T | T | 0.125 |\n",
       "\n"
      ],
      "text/plain": [
       "  toss1 toss2 toss3 probs\n",
       "1 H     H     H     0.125\n",
       "2 T     H     H     0.125\n",
       "3 H     T     H     0.125\n",
       "4 T     T     H     0.125\n",
       "5 H     H     T     0.125\n",
       "6 T     H     T     0.125\n",
       "7 H     T     T     0.125\n",
       "8 T     T     T     0.125"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tosscoin(3, makespace = T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones en *R* para obtener información o ayuda de paquetes o funciones mismas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función [sample](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/sample) se encuentra en el paquete *base* de R y se puede obtener la ayuda de este paquete con la sintaxis `?<package>` o `help(<package>)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<table width=\"100%\" summary=\"page for base-package {base}\"><tr><td>base-package {base}</td><td style=\"text-align: right;\">R Documentation</td></tr></table>\n",
       "\n",
       "<h2>\n",
       "The R Base Package\n",
       "</h2>\n",
       "\n",
       "<h3>Description</h3>\n",
       "\n",
       "<p>Base R functions\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Details</h3>\n",
       "\n",
       "<p>This package contains the basic functions which let <span style=\"font-family: Courier New, Courier; color: #666666;\"><b>R</b></span>\n",
       "function as a language:  arithmetic, input/output, basic\n",
       "programming support, etc.  Its contents are available through\n",
       "inheritance from any environment.\n",
       "</p>\n",
       "<p>For a complete list of functions, use <code>library(help = \"base\")</code>.\n",
       "</p>\n",
       "\n",
       "<hr /><div style=\"text-align: center;\">[Package <em>base</em> version 4.1.0 ]</div>"
      ],
      "text/latex": [
       "\\inputencoding{utf8}\n",
       "\\HeaderA{base-package}{The R Base Package}{base.Rdash.package}\n",
       "\\aliasA{base}{base-package}{base}\n",
       "\\keyword{package}{base-package}\n",
       "%\n",
       "\\begin{Description}\\relax\n",
       "Base R functions\n",
       "\\end{Description}\n",
       "%\n",
       "\\begin{Details}\\relax\n",
       "This package contains the basic functions which let \\R{}\n",
       "function as a language:  arithmetic, input/output, basic\n",
       "programming support, etc.  Its contents are available through\n",
       "inheritance from any environment.\n",
       "\n",
       "For a complete list of functions, use \\code{library(help = \"base\")}.\n",
       "\\end{Details}"
      ],
      "text/plain": [
       "base-package               package:base                R Documentation\n",
       "\n",
       "_\bT_\bh_\be _\bR _\bB_\ba_\bs_\be _\bP_\ba_\bc_\bk_\ba_\bg_\be\n",
       "\n",
       "_\bD_\be_\bs_\bc_\br_\bi_\bp_\bt_\bi_\bo_\bn:\n",
       "\n",
       "     Base R functions\n",
       "\n",
       "_\bD_\be_\bt_\ba_\bi_\bl_\bs:\n",
       "\n",
       "     This package contains the basic functions which let R function as\n",
       "     a language: arithmetic, input/output, basic programming support,\n",
       "     etc.  Its contents are available through inheritance from any\n",
       "     environment.\n",
       "\n",
       "     For a complete list of functions, use ‘library(help = \"base\")’.\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo como se hizo `library(prob)` anteriormente (y se tiene enmascaramiento de algunos objetos) si ejecutamos la ayuda para la función de `sample` (la cual también se puede obtener con `?<func>` o `help(func)`) se obtiene:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación** \n",
    "\n",
    "Obsérvese que sample aparece en el paquete timeDate y no en el paquete base ...\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<table width=\"100%\" summary=\"page for sample {timeDate}\"><tr><td>sample {timeDate}</td><td style=\"text-align: right;\">R Documentation</td></tr></table>\n",
       "\n",
       "<h2>Resampling 'timeDate' Objects</h2>\n",
       "\n",
       "<h3>Description</h3>\n",
       "\n",
       "<p>Resamples a 'timeDate' object.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Value</h3>\n",
       "\n",
       "<p>returns an object of class <code>\"timeDate\"</code>.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Examples</h3>\n",
       "\n",
       "<pre>\n",
       "## c -\n",
       "   # Create Character Vectors:\n",
       "   dts = c(\"1989-09-28\", \"2001-01-15\", \"2004-08-30\", \"1990-02-09\")\n",
       "   dts\n",
       "   tms = c(  \"23:12:55\",   \"10:34:02\",   \"08:30:00\",   \"11:18:23\")\n",
       "   tms\n",
       "   \n",
       "## \"+/-\" - \n",
       "   # Add One Day to a Given timeDate Object:\n",
       "   GMT = timeDate(dts, zone = \"GMT\", FinCenter = \"GMT\")\n",
       "   GMT\n",
       "   ZUR = timeDate(dts, zone = \"GMT\", FinCenter = \"Europe/Zurich\")\n",
       "   ZUR\n",
       "   \n",
       "## c - \n",
       "   # Concatenate and Replicate timeDate Objects:\n",
       "   c(GMT[1:2], ZUR[1:2])\n",
       "   c(ZUR[1:2], GMT[1:2])\n",
       "   \n",
       "## rep - \n",
       "   rep(ZUR[2], times = 3)\n",
       "   rep(ZUR[2:3], times = 2)  \n",
       "</pre>\n",
       "\n",
       "<hr /><div style=\"text-align: center;\">[Package <em>timeDate</em> version 3043.102 ]</div>"
      ],
      "text/latex": [
       "\\inputencoding{utf8}\n",
       "\\HeaderA{sample}{Resampling 'timeDate' Objects}{sample}\n",
       "\\aliasA{sample,timeDate-method}{sample}{sample,timeDate.Rdash.method}\n",
       "\\keyword{chron}{sample}\n",
       "%\n",
       "\\begin{Description}\\relax\n",
       "\n",
       "Resamples a 'timeDate' object.\n",
       "\\end{Description}\n",
       "%\n",
       "\\begin{Value}\n",
       "\n",
       "returns an object of class \\code{\"timeDate\"}.\n",
       "\n",
       "\\end{Value}\n",
       "%\n",
       "\\begin{Examples}\n",
       "\\begin{ExampleCode}\n",
       "## c -\n",
       "   # Create Character Vectors:\n",
       "   dts = c(\"1989-09-28\", \"2001-01-15\", \"2004-08-30\", \"1990-02-09\")\n",
       "   dts\n",
       "   tms = c(  \"23:12:55\",   \"10:34:02\",   \"08:30:00\",   \"11:18:23\")\n",
       "   tms\n",
       "   \n",
       "## \"+/-\" - \n",
       "   # Add One Day to a Given timeDate Object:\n",
       "   GMT = timeDate(dts, zone = \"GMT\", FinCenter = \"GMT\")\n",
       "   GMT\n",
       "   ZUR = timeDate(dts, zone = \"GMT\", FinCenter = \"Europe/Zurich\")\n",
       "   ZUR\n",
       "   \n",
       "## c - \n",
       "   # Concatenate and Replicate timeDate Objects:\n",
       "   c(GMT[1:2], ZUR[1:2])\n",
       "   c(ZUR[1:2], GMT[1:2])\n",
       "   \n",
       "## rep - \n",
       "   rep(ZUR[2], times = 3)\n",
       "   rep(ZUR[2:3], times = 2)  \n",
       "\\end{ExampleCode}\n",
       "\\end{Examples}"
      ],
      "text/plain": [
       "sample                package:timeDate                 R Documentation\n",
       "\n",
       "_\bR_\be_\bs_\ba_\bm_\bp_\bl_\bi_\bn_\bg '_\bt_\bi_\bm_\be_\bD_\ba_\bt_\be' _\bO_\bb_\bj_\be_\bc_\bt_\bs\n",
       "\n",
       "_\bD_\be_\bs_\bc_\br_\bi_\bp_\bt_\bi_\bo_\bn:\n",
       "\n",
       "     Resamples a 'timeDate' object.\n",
       "\n",
       "_\bV_\ba_\bl_\bu_\be:\n",
       "\n",
       "     returns an object of class ‘\"timeDate\"’.\n",
       "\n",
       "_\bE_\bx_\ba_\bm_\bp_\bl_\be_\bs:\n",
       "\n",
       "     ## c -\n",
       "        # Create Character Vectors:\n",
       "        dts = c(\"1989-09-28\", \"2001-01-15\", \"2004-08-30\", \"1990-02-09\")\n",
       "        dts\n",
       "        tms = c(  \"23:12:55\",   \"10:34:02\",   \"08:30:00\",   \"11:18:23\")\n",
       "        tms\n",
       "        \n",
       "     ## \"+/-\" - \n",
       "        # Add One Day to a Given timeDate Object:\n",
       "        GMT = timeDate(dts, zone = \"GMT\", FinCenter = \"GMT\")\n",
       "        GMT\n",
       "        ZUR = timeDate(dts, zone = \"GMT\", FinCenter = \"Europe/Zurich\")\n",
       "        ZUR\n",
       "        \n",
       "     ## c - \n",
       "        # Concatenate and Replicate timeDate Objects:\n",
       "        c(GMT[1:2], ZUR[1:2])\n",
       "        c(ZUR[1:2], GMT[1:2])\n",
       "        \n",
       "     ## rep - \n",
       "        rep(ZUR[2], times = 3)\n",
       "        rep(ZUR[2:3], times = 2)  \n",
       "     "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?sample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y observando que el paquete `timeDate` también tiene una función `sample` en el output de arriba o con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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>'package:timeSeries'</li><li>'package:timeDate'</li><li>'package:base'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'package:timeSeries'\n",
       "\\item 'package:timeDate'\n",
       "\\item 'package:base'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'package:timeSeries'\n",
       "2. 'package:timeDate'\n",
       "3. 'package:base'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"package:timeSeries\" \"package:timeDate\"   \"package:base\"      "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "find(\"sample\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "entonces se tiene un enmascaramiento entre `sample` del paquete `base` y el paquete `timeDate`. Por lo que se puede acceder a la ayuda de `sample` del paquete `timeDate` con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<table width=\"100%\" summary=\"page for sample {timeDate}\"><tr><td>sample {timeDate}</td><td style=\"text-align: right;\">R Documentation</td></tr></table>\n",
       "\n",
       "<h2>Resampling 'timeDate' Objects</h2>\n",
       "\n",
       "<h3>Description</h3>\n",
       "\n",
       "<p>Resamples a 'timeDate' object.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Value</h3>\n",
       "\n",
       "<p>returns an object of class <code>\"timeDate\"</code>.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Examples</h3>\n",
       "\n",
       "<pre>\n",
       "## c -\n",
       "   # Create Character Vectors:\n",
       "   dts = c(\"1989-09-28\", \"2001-01-15\", \"2004-08-30\", \"1990-02-09\")\n",
       "   dts\n",
       "   tms = c(  \"23:12:55\",   \"10:34:02\",   \"08:30:00\",   \"11:18:23\")\n",
       "   tms\n",
       "   \n",
       "## \"+/-\" - \n",
       "   # Add One Day to a Given timeDate Object:\n",
       "   GMT = timeDate(dts, zone = \"GMT\", FinCenter = \"GMT\")\n",
       "   GMT\n",
       "   ZUR = timeDate(dts, zone = \"GMT\", FinCenter = \"Europe/Zurich\")\n",
       "   ZUR\n",
       "   \n",
       "## c - \n",
       "   # Concatenate and Replicate timeDate Objects:\n",
       "   c(GMT[1:2], ZUR[1:2])\n",
       "   c(ZUR[1:2], GMT[1:2])\n",
       "   \n",
       "## rep - \n",
       "   rep(ZUR[2], times = 3)\n",
       "   rep(ZUR[2:3], times = 2)  \n",
       "</pre>\n",
       "\n",
       "<hr /><div style=\"text-align: center;\">[Package <em>timeDate</em> version 3043.102 ]</div>"
      ],
      "text/latex": [
       "\\inputencoding{utf8}\n",
       "\\HeaderA{sample}{Resampling 'timeDate' Objects}{sample}\n",
       "\\aliasA{sample,timeDate-method}{sample}{sample,timeDate.Rdash.method}\n",
       "\\keyword{chron}{sample}\n",
       "%\n",
       "\\begin{Description}\\relax\n",
       "\n",
       "Resamples a 'timeDate' object.\n",
       "\\end{Description}\n",
       "%\n",
       "\\begin{Value}\n",
       "\n",
       "returns an object of class \\code{\"timeDate\"}.\n",
       "\n",
       "\\end{Value}\n",
       "%\n",
       "\\begin{Examples}\n",
       "\\begin{ExampleCode}\n",
       "## c -\n",
       "   # Create Character Vectors:\n",
       "   dts = c(\"1989-09-28\", \"2001-01-15\", \"2004-08-30\", \"1990-02-09\")\n",
       "   dts\n",
       "   tms = c(  \"23:12:55\",   \"10:34:02\",   \"08:30:00\",   \"11:18:23\")\n",
       "   tms\n",
       "   \n",
       "## \"+/-\" - \n",
       "   # Add One Day to a Given timeDate Object:\n",
       "   GMT = timeDate(dts, zone = \"GMT\", FinCenter = \"GMT\")\n",
       "   GMT\n",
       "   ZUR = timeDate(dts, zone = \"GMT\", FinCenter = \"Europe/Zurich\")\n",
       "   ZUR\n",
       "   \n",
       "## c - \n",
       "   # Concatenate and Replicate timeDate Objects:\n",
       "   c(GMT[1:2], ZUR[1:2])\n",
       "   c(ZUR[1:2], GMT[1:2])\n",
       "   \n",
       "## rep - \n",
       "   rep(ZUR[2], times = 3)\n",
       "   rep(ZUR[2:3], times = 2)  \n",
       "\\end{ExampleCode}\n",
       "\\end{Examples}"
      ],
      "text/plain": [
       "sample                package:timeDate                 R Documentation\n",
       "\n",
       "_\bR_\be_\bs_\ba_\bm_\bp_\bl_\bi_\bn_\bg '_\bt_\bi_\bm_\be_\bD_\ba_\bt_\be' _\bO_\bb_\bj_\be_\bc_\bt_\bs\n",
       "\n",
       "_\bD_\be_\bs_\bc_\br_\bi_\bp_\bt_\bi_\bo_\bn:\n",
       "\n",
       "     Resamples a 'timeDate' object.\n",
       "\n",
       "_\bV_\ba_\bl_\bu_\be:\n",
       "\n",
       "     returns an object of class ‘\"timeDate\"’.\n",
       "\n",
       "_\bE_\bx_\ba_\bm_\bp_\bl_\be_\bs:\n",
       "\n",
       "     ## c -\n",
       "        # Create Character Vectors:\n",
       "        dts = c(\"1989-09-28\", \"2001-01-15\", \"2004-08-30\", \"1990-02-09\")\n",
       "        dts\n",
       "        tms = c(  \"23:12:55\",   \"10:34:02\",   \"08:30:00\",   \"11:18:23\")\n",
       "        tms\n",
       "        \n",
       "     ## \"+/-\" - \n",
       "        # Add One Day to a Given timeDate Object:\n",
       "        GMT = timeDate(dts, zone = \"GMT\", FinCenter = \"GMT\")\n",
       "        GMT\n",
       "        ZUR = timeDate(dts, zone = \"GMT\", FinCenter = \"Europe/Zurich\")\n",
       "        ZUR\n",
       "        \n",
       "     ## c - \n",
       "        # Concatenate and Replicate timeDate Objects:\n",
       "        c(GMT[1:2], ZUR[1:2])\n",
       "        c(ZUR[1:2], GMT[1:2])\n",
       "        \n",
       "     ## rep - \n",
       "        rep(ZUR[2], times = 3)\n",
       "        rep(ZUR[2:3], times = 2)  \n",
       "     "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?timeDate::sample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y para la función `sample` del `base package` que nos interesa debemos hacer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<table width=\"100%\" summary=\"page for sample {base}\"><tr><td>sample {base}</td><td style=\"text-align: right;\">R Documentation</td></tr></table>\n",
       "\n",
       "<h2>Random Samples and Permutations</h2>\n",
       "\n",
       "<h3>Description</h3>\n",
       "\n",
       "<p><code>sample</code> takes a sample of the specified size from the elements\n",
       "of <code>x</code> using either with or without replacement.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Usage</h3>\n",
       "\n",
       "<pre>\n",
       "sample(x, size, replace = FALSE, prob = NULL)\n",
       "\n",
       "sample.int(n, size = n, replace = FALSE, prob = NULL,\n",
       "           useHash = (!replace &amp;&amp; is.null(prob) &amp;&amp; size &lt;= n/2 &amp;&amp; n &gt; 1e7))\n",
       "</pre>\n",
       "\n",
       "\n",
       "<h3>Arguments</h3>\n",
       "\n",
       "<table summary=\"R argblock\">\n",
       "<tr valign=\"top\"><td><code>x</code></td>\n",
       "<td>\n",
       "<p>either a vector of one or more elements from which to choose,\n",
       "or a positive integer.  See &lsquo;Details.&rsquo;</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>n</code></td>\n",
       "<td>\n",
       "<p>a positive number, the number of items to choose from.  See\n",
       "&lsquo;Details.&rsquo;</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>size</code></td>\n",
       "<td>\n",
       "<p>a non-negative integer giving the number of items to choose.</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>replace</code></td>\n",
       "<td>\n",
       "<p>should sampling be with replacement?</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>prob</code></td>\n",
       "<td>\n",
       "<p>a vector of probability weights for obtaining the elements\n",
       "of the vector being sampled.</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>useHash</code></td>\n",
       "<td>\n",
       "<p><code>logical</code> indicating if the hash-version of\n",
       "the algorithm should be used.  Can only be used for <code>replace =\n",
       "      FALSE</code>, <code>prob = NULL</code>, and <code>size &lt;= n/2</code>, and really\n",
       "should be used for large <code>n</code>, as <code>useHash=FALSE</code> will use\n",
       "memory proportional to <code>n</code>.</p>\n",
       "</td></tr>\n",
       "</table>\n",
       "\n",
       "\n",
       "<h3>Details</h3>\n",
       "\n",
       "<p>If <code>x</code> has length 1, is numeric (in the sense of\n",
       "<code>is.numeric</code>) and <code>x &gt;= 1</code>, sampling <em>via</em>\n",
       "<code>sample</code> takes place from <code>1:x</code>.  <em>Note</em> that this\n",
       "convenience feature may lead to undesired behaviour when <code>x</code> is\n",
       "of varying length in calls such as <code>sample(x)</code>.  See the examples.\n",
       "</p>\n",
       "<p>Otherwise <code>x</code> can be any <span style=\"font-family: Courier New, Courier; color: #666666;\"><b>R</b></span> object for which <code>length</code> and\n",
       "subsetting by integers make sense: S3 or S4 methods for these\n",
       "operations will be dispatched as appropriate.\n",
       "</p>\n",
       "<p>For <code>sample</code> the default for <code>size</code> is the number of items\n",
       "inferred from the first argument, so that <code>sample(x)</code> generates a\n",
       "random permutation of the elements of <code>x</code> (or <code>1:x</code>).\n",
       "</p>\n",
       "<p>It is allowed to ask for <code>size = 0</code> samples with <code>n = 0</code> or\n",
       "a length-zero <code>x</code>, but otherwise <code>n &gt; 0</code> or positive\n",
       "<code>length(x)</code> is required.\n",
       "</p>\n",
       "<p>Non-integer positive numerical values of <code>n</code> or <code>x</code> will be\n",
       "truncated to the next smallest integer, which has to be no larger than\n",
       "<code>.Machine$integer.max</code>.\n",
       "</p>\n",
       "<p>The optional <code>prob</code> argument can be used to give a vector of\n",
       "weights for obtaining the elements of the vector being sampled.  They\n",
       "need not sum to one, but they should be non-negative and not all zero.\n",
       "If <code>replace</code> is true, Walker's alias method (Ripley, 1987) is\n",
       "used when there are more than 200 reasonably probable values: this\n",
       "gives results incompatible with those from <span style=\"font-family: Courier New, Courier; color: #666666;\"><b>R</b></span> &lt; 2.2.0.\n",
       "</p>\n",
       "<p>If <code>replace</code> is false, these probabilities are applied\n",
       "sequentially, that is the probability of choosing the next item is\n",
       "proportional to the weights amongst the remaining items.  The number\n",
       "of nonzero weights must be at least <code>size</code> in this case.\n",
       "</p>\n",
       "<p><code>sample.int</code> is a bare interface in which both <code>n</code> and\n",
       "<code>size</code> must be supplied as integers.\n",
       "</p>\n",
       "<p>Argument <code>n</code> can be larger than the largest integer of\n",
       "type <code>integer</code>, up to the largest representable integer in type\n",
       "<code>double</code>.  Only uniform sampling is supported.  Two\n",
       "random numbers are used to ensure uniform sampling of large integers.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Value</h3>\n",
       "\n",
       "<p>For <code>sample</code> a vector of length <code>size</code> with elements\n",
       "drawn from either <code>x</code> or from the integers <code>1:x</code>.\n",
       "</p>\n",
       "<p>For <code>sample.int</code>, an integer vector of length <code>size</code> with\n",
       "elements from <code>1:n</code>, or a double vector if\n",
       "<i>n &gt;= 2^31</i>.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>References</h3>\n",
       "\n",
       "<p>Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)\n",
       "<em>The New S Language</em>.\n",
       "Wadsworth &amp; Brooks/Cole.\n",
       "</p>\n",
       "<p>Ripley, B. D. (1987) <em>Stochastic Simulation</em>. Wiley.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>See Also</h3>\n",
       "\n",
       "<p><code>RNGkind(sample.kind = ..)</code> about random number generation,\n",
       "notably the change of <code>sample()</code> results with <span style=\"font-family: Courier New, Courier; color: #666666;\"><b>R</b></span> version 3.6.0.\n",
       "</p>\n",
       "<p>CRAN package <a href=\"https://CRAN.R-project.org/package=sampling\"><span class=\"pkg\">sampling</span></a> for other methods of weighted sampling\n",
       "without replacement.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Examples</h3>\n",
       "\n",
       "<pre>\n",
       "x &lt;- 1:12\n",
       "# a random permutation\n",
       "sample(x)\n",
       "# bootstrap resampling -- only if length(x) &gt; 1 !\n",
       "sample(x, replace = TRUE)\n",
       "\n",
       "# 100 Bernoulli trials\n",
       "sample(c(0,1), 100, replace = TRUE)\n",
       "\n",
       "## More careful bootstrapping --  Consider this when using sample()\n",
       "## programmatically (i.e., in your function or simulation)!\n",
       "\n",
       "# sample()'s surprise -- example\n",
       "x &lt;- 1:10\n",
       "    sample(x[x &gt;  8]) # length 2\n",
       "    sample(x[x &gt;  9]) # oops -- length 10!\n",
       "    sample(x[x &gt; 10]) # length 0\n",
       "\n",
       "## safer version:\n",
       "resample &lt;- function(x, ...) x[sample.int(length(x), ...)]\n",
       "resample(x[x &gt;  8]) # length 2\n",
       "resample(x[x &gt;  9]) # length 1\n",
       "resample(x[x &gt; 10]) # length 0\n",
       "\n",
       "## R 3.x.y only\n",
       "sample.int(1e10, 12, replace = TRUE)\n",
       "sample.int(1e10, 12) # not that there is much chance of duplicates\n",
       "</pre>\n",
       "\n",
       "<hr /><div style=\"text-align: center;\">[Package <em>base</em> version 4.1.0 ]</div>"
      ],
      "text/latex": [
       "\\inputencoding{utf8}\n",
       "\\HeaderA{sample}{Random Samples and Permutations}{sample}\n",
       "\\methaliasA{sample.int}{sample}{sample.int}\n",
       "\\keyword{distribution}{sample}\n",
       "%\n",
       "\\begin{Description}\\relax\n",
       "\\code{sample} takes a sample of the specified size from the elements\n",
       "of \\code{x} using either with or without replacement.\n",
       "\\end{Description}\n",
       "%\n",
       "\\begin{Usage}\n",
       "\\begin{verbatim}\n",
       "sample(x, size, replace = FALSE, prob = NULL)\n",
       "\n",
       "sample.int(n, size = n, replace = FALSE, prob = NULL,\n",
       "           useHash = (!replace && is.null(prob) && size <= n/2 && n > 1e7))\n",
       "\\end{verbatim}\n",
       "\\end{Usage}\n",
       "%\n",
       "\\begin{Arguments}\n",
       "\\begin{ldescription}\n",
       "\\item[\\code{x}] either a vector of one or more elements from which to choose,\n",
       "or a positive integer.  See `Details.'\n",
       "\\item[\\code{n}] a positive number, the number of items to choose from.  See\n",
       "`Details.'\n",
       "\\item[\\code{size}] a non-negative integer giving the number of items to choose.\n",
       "\\item[\\code{replace}] should sampling be with replacement?\n",
       "\\item[\\code{prob}] a vector of probability weights for obtaining the elements\n",
       "of the vector being sampled.\n",
       "\\item[\\code{useHash}] \\code{\\LinkA{logical}{logical}} indicating if the hash-version of\n",
       "the algorithm should be used.  Can only be used for \\code{replace =\n",
       "      FALSE}, \\code{prob = NULL}, and \\code{size <= n/2}, and really\n",
       "should be used for large \\code{n}, as \\code{useHash=FALSE} will use\n",
       "memory proportional to \\code{n}.\n",
       "\\end{ldescription}\n",
       "\\end{Arguments}\n",
       "%\n",
       "\\begin{Details}\\relax\n",
       "If \\code{x} has length 1, is numeric (in the sense of\n",
       "\\code{\\LinkA{is.numeric}{is.numeric}}) and \\code{x >= 1}, sampling \\emph{via}\n",
       "\\code{sample} takes place from \\code{1:x}.  \\emph{Note} that this\n",
       "convenience feature may lead to undesired behaviour when \\code{x} is\n",
       "of varying length in calls such as \\code{sample(x)}.  See the examples.\n",
       "\n",
       "Otherwise \\code{x} can be any \\R{} object for which \\code{length} and\n",
       "subsetting by integers make sense: S3 or S4 methods for these\n",
       "operations will be dispatched as appropriate.\n",
       "\n",
       "For \\code{sample} the default for \\code{size} is the number of items\n",
       "inferred from the first argument, so that \\code{sample(x)} generates a\n",
       "random permutation of the elements of \\code{x} (or \\code{1:x}).\n",
       "\n",
       "It is allowed to ask for \\code{size = 0} samples with \\code{n = 0} or\n",
       "a length-zero \\code{x}, but otherwise \\code{n > 0} or positive\n",
       "\\code{length(x)} is required.\n",
       "\n",
       "Non-integer positive numerical values of \\code{n} or \\code{x} will be\n",
       "truncated to the next smallest integer, which has to be no larger than\n",
       "\\code{\\LinkA{.Machine}{.Machine}\\$integer.max}.\n",
       "\n",
       "The optional \\code{prob} argument can be used to give a vector of\n",
       "weights for obtaining the elements of the vector being sampled.  They\n",
       "need not sum to one, but they should be non-negative and not all zero.\n",
       "If \\code{replace} is true, Walker's alias method (Ripley, 1987) is\n",
       "used when there are more than 200 reasonably probable values: this\n",
       "gives results incompatible with those from \\R{} < 2.2.0.\n",
       "\n",
       "If \\code{replace} is false, these probabilities are applied\n",
       "sequentially, that is the probability of choosing the next item is\n",
       "proportional to the weights amongst the remaining items.  The number\n",
       "of nonzero weights must be at least \\code{size} in this case.\n",
       "\n",
       "\\code{sample.int} is a bare interface in which both \\code{n} and\n",
       "\\code{size} must be supplied as integers.\n",
       "\n",
       "Argument \\code{n} can be larger than the largest integer of\n",
       "type \\code{integer}, up to the largest representable integer in type\n",
       "\\code{double}.  Only uniform sampling is supported.  Two\n",
       "random numbers are used to ensure uniform sampling of large integers.\n",
       "\\end{Details}\n",
       "%\n",
       "\\begin{Value}\n",
       "For \\code{sample} a vector of length \\code{size} with elements\n",
       "drawn from either \\code{x} or from the integers \\code{1:x}.\n",
       "\n",
       "For \\code{sample.int}, an integer vector of length \\code{size} with\n",
       "elements from \\code{1:n}, or a double vector if\n",
       "\\eqn{n \\ge 2^{31}}{}.\n",
       "\\end{Value}\n",
       "%\n",
       "\\begin{References}\\relax\n",
       "Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)\n",
       "\\emph{The New S Language}.\n",
       "Wadsworth \\& Brooks/Cole.\n",
       "\n",
       "Ripley, B. D. (1987) \\emph{Stochastic Simulation}. Wiley.\n",
       "\\end{References}\n",
       "%\n",
       "\\begin{SeeAlso}\\relax\n",
       "\\code{\\LinkA{RNGkind}{RNGkind}(sample.kind = ..)} about random number generation,\n",
       "notably the change of \\code{sample()} results with \\R{} version 3.6.0.\n",
       "\n",
       "CRAN package \\Rhref{https://CRAN.R-project.org/package=sampling}{\\pkg{sampling}} for other methods of weighted sampling\n",
       "without replacement.\n",
       "\\end{SeeAlso}\n",
       "%\n",
       "\\begin{Examples}\n",
       "\\begin{ExampleCode}\n",
       "x <- 1:12\n",
       "# a random permutation\n",
       "sample(x)\n",
       "# bootstrap resampling -- only if length(x) > 1 !\n",
       "sample(x, replace = TRUE)\n",
       "\n",
       "# 100 Bernoulli trials\n",
       "sample(c(0,1), 100, replace = TRUE)\n",
       "\n",
       "## More careful bootstrapping --  Consider this when using sample()\n",
       "## programmatically (i.e., in your function or simulation)!\n",
       "\n",
       "# sample()'s surprise -- example\n",
       "x <- 1:10\n",
       "    sample(x[x >  8]) # length 2\n",
       "    sample(x[x >  9]) # oops -- length 10!\n",
       "    sample(x[x > 10]) # length 0\n",
       "\n",
       "## safer version:\n",
       "resample <- function(x, ...) x[sample.int(length(x), ...)]\n",
       "resample(x[x >  8]) # length 2\n",
       "resample(x[x >  9]) # length 1\n",
       "resample(x[x > 10]) # length 0\n",
       "\n",
       "## R 3.x.y only\n",
       "sample.int(1e10, 12, replace = TRUE)\n",
       "sample.int(1e10, 12) # not that there is much chance of duplicates\n",
       "\\end{ExampleCode}\n",
       "\\end{Examples}"
      ],
      "text/plain": [
       "sample                  package:base                   R Documentation\n",
       "\n",
       "_\bR_\ba_\bn_\bd_\bo_\bm _\bS_\ba_\bm_\bp_\bl_\be_\bs _\ba_\bn_\bd _\bP_\be_\br_\bm_\bu_\bt_\ba_\bt_\bi_\bo_\bn_\bs\n",
       "\n",
       "_\bD_\be_\bs_\bc_\br_\bi_\bp_\bt_\bi_\bo_\bn:\n",
       "\n",
       "     ‘sample’ takes a sample of the specified size from the elements of\n",
       "     ‘x’ using either with or without replacement.\n",
       "\n",
       "_\bU_\bs_\ba_\bg_\be:\n",
       "\n",
       "     sample(x, size, replace = FALSE, prob = NULL)\n",
       "     \n",
       "     sample.int(n, size = n, replace = FALSE, prob = NULL,\n",
       "                useHash = (!replace && is.null(prob) && size <= n/2 && n > 1e7))\n",
       "     \n",
       "_\bA_\br_\bg_\bu_\bm_\be_\bn_\bt_\bs:\n",
       "\n",
       "       x: either a vector of one or more elements from which to choose,\n",
       "          or a positive integer.  See ‘Details.’\n",
       "\n",
       "       n: a positive number, the number of items to choose from.  See\n",
       "          ‘Details.’\n",
       "\n",
       "    size: a non-negative integer giving the number of items to choose.\n",
       "\n",
       " replace: should sampling be with replacement?\n",
       "\n",
       "    prob: a vector of probability weights for obtaining the elements of\n",
       "          the vector being sampled.\n",
       "\n",
       " useHash: ‘logical’ indicating if the hash-version of the algorithm\n",
       "          should be used.  Can only be used for ‘replace = FALSE’,\n",
       "          ‘prob = NULL’, and ‘size <= n/2’, and really should be used\n",
       "          for large ‘n’, as ‘useHash=FALSE’ will use memory\n",
       "          proportional to ‘n’.\n",
       "\n",
       "_\bD_\be_\bt_\ba_\bi_\bl_\bs:\n",
       "\n",
       "     If ‘x’ has length 1, is numeric (in the sense of ‘is.numeric’) and\n",
       "     ‘x >= 1’, sampling _via_ ‘sample’ takes place from ‘1:x’.  _Note_\n",
       "     that this convenience feature may lead to undesired behaviour when\n",
       "     ‘x’ is of varying length in calls such as ‘sample(x)’.  See the\n",
       "     examples.\n",
       "\n",
       "     Otherwise ‘x’ can be any R object for which ‘length’ and\n",
       "     subsetting by integers make sense: S3 or S4 methods for these\n",
       "     operations will be dispatched as appropriate.\n",
       "\n",
       "     For ‘sample’ the default for ‘size’ is the number of items\n",
       "     inferred from the first argument, so that ‘sample(x)’ generates a\n",
       "     random permutation of the elements of ‘x’ (or ‘1:x’).\n",
       "\n",
       "     It is allowed to ask for ‘size = 0’ samples with ‘n = 0’ or a\n",
       "     length-zero ‘x’, but otherwise ‘n > 0’ or positive ‘length(x)’ is\n",
       "     required.\n",
       "\n",
       "     Non-integer positive numerical values of ‘n’ or ‘x’ will be\n",
       "     truncated to the next smallest integer, which has to be no larger\n",
       "     than ‘.Machine$integer.max’.\n",
       "\n",
       "     The optional ‘prob’ argument can be used to give a vector of\n",
       "     weights for obtaining the elements of the vector being sampled.\n",
       "     They need not sum to one, but they should be non-negative and not\n",
       "     all zero.  If ‘replace’ is true, Walker's alias method (Ripley,\n",
       "     1987) is used when there are more than 200 reasonably probable\n",
       "     values: this gives results incompatible with those from R < 2.2.0.\n",
       "\n",
       "     If ‘replace’ is false, these probabilities are applied\n",
       "     sequentially, that is the probability of choosing the next item is\n",
       "     proportional to the weights amongst the remaining items.  The\n",
       "     number of nonzero weights must be at least ‘size’ in this case.\n",
       "\n",
       "     ‘sample.int’ is a bare interface in which both ‘n’ and ‘size’ must\n",
       "     be supplied as integers.\n",
       "\n",
       "     Argument ‘n’ can be larger than the largest integer of type\n",
       "     ‘integer’, up to the largest representable integer in type\n",
       "     ‘double’.  Only uniform sampling is supported.  Two random numbers\n",
       "     are used to ensure uniform sampling of large integers.\n",
       "\n",
       "_\bV_\ba_\bl_\bu_\be:\n",
       "\n",
       "     For ‘sample’ a vector of length ‘size’ with elements drawn from\n",
       "     either ‘x’ or from the integers ‘1:x’.\n",
       "\n",
       "     For ‘sample.int’, an integer vector of length ‘size’ with elements\n",
       "     from ‘1:n’, or a double vector if n >= 2^31.\n",
       "\n",
       "_\bR_\be_\bf_\be_\br_\be_\bn_\bc_\be_\bs:\n",
       "\n",
       "     Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S\n",
       "     Language_.  Wadsworth & Brooks/Cole.\n",
       "\n",
       "     Ripley, B. D. (1987) _Stochastic Simulation_. Wiley.\n",
       "\n",
       "_\bS_\be_\be _\bA_\bl_\bs_\bo:\n",
       "\n",
       "     ‘RNGkind(sample.kind = ..)’ about random number generation,\n",
       "     notably the change of ‘sample()’ results with R version 3.6.0.\n",
       "\n",
       "     CRAN package ‘sampling’ for other methods of weighted sampling\n",
       "     without replacement.\n",
       "\n",
       "_\bE_\bx_\ba_\bm_\bp_\bl_\be_\bs:\n",
       "\n",
       "     x <- 1:12\n",
       "     # a random permutation\n",
       "     sample(x)\n",
       "     # bootstrap resampling -- only if length(x) > 1 !\n",
       "     sample(x, replace = TRUE)\n",
       "     \n",
       "     # 100 Bernoulli trials\n",
       "     sample(c(0,1), 100, replace = TRUE)\n",
       "     \n",
       "     ## More careful bootstrapping --  Consider this when using sample()\n",
       "     ## programmatically (i.e., in your function or simulation)!\n",
       "     \n",
       "     # sample()'s surprise -- example\n",
       "     x <- 1:10\n",
       "         sample(x[x >  8]) # length 2\n",
       "         sample(x[x >  9]) # oops -- length 10!\n",
       "         sample(x[x > 10]) # length 0\n",
       "     \n",
       "     ## safer version:\n",
       "     resample <- function(x, ...) x[sample.int(length(x), ...)]\n",
       "     resample(x[x >  8]) # length 2\n",
       "     resample(x[x >  9]) # length 1\n",
       "     resample(x[x > 10]) # length 0\n",
       "     \n",
       "     ## R 3.x.y only\n",
       "     sample.int(1e10, 12, replace = TRUE)\n",
       "     sample.int(1e10, 12) # not that there is much chance of duplicates\n",
       "     "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?base::sample "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos ejecutar los ejemplos de la ayuda anterior, se utiliza la función `example`. A continuación se muestran los argumentos que recibe la función `example`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre class=language-r><code>function (topic, package = NULL, lib.loc = NULL, character.only = FALSE, \n",
       "<span style=white-space:pre-wrap>    give.lines = FALSE, local = FALSE, echo = TRUE, verbose = getOption(\"verbose\"), </span>\n",
       "<span style=white-space:pre-wrap>    setRNG = FALSE, ask = getOption(\"example.ask\"), prompt.prefix = abbreviate(topic, </span>\n",
       "<span style=white-space:pre-wrap>        6), run.dontrun = FALSE, run.donttest = interactive()) </span>\n",
       "NULL</code></pre>"
      ],
      "text/latex": [
       "\\begin{minted}{r}\n",
       "function (topic, package = NULL, lib.loc = NULL, character.only = FALSE, \n",
       "    give.lines = FALSE, local = FALSE, echo = TRUE, verbose = getOption(\"verbose\"), \n",
       "    setRNG = FALSE, ask = getOption(\"example.ask\"), prompt.prefix = abbreviate(topic, \n",
       "        6), run.dontrun = FALSE, run.donttest = interactive()) \n",
       "NULL\n",
       "\\end{minted}"
      ],
      "text/markdown": [
       "```r\n",
       "function (topic, package = NULL, lib.loc = NULL, character.only = FALSE, \n",
       "    give.lines = FALSE, local = FALSE, echo = TRUE, verbose = getOption(\"verbose\"), \n",
       "    setRNG = FALSE, ask = getOption(\"example.ask\"), prompt.prefix = abbreviate(topic, \n",
       "        6), run.dontrun = FALSE, run.donttest = interactive()) \n",
       "NULL\n",
       "```"
      ],
      "text/plain": [
       "function (topic, package = NULL, lib.loc = NULL, character.only = FALSE, \n",
       "    give.lines = FALSE, local = FALSE, echo = TRUE, verbose = getOption(\"verbose\"), \n",
       "    setRNG = FALSE, ask = getOption(\"example.ask\"), prompt.prefix = abbreviate(topic, \n",
       "        6), run.dontrun = FALSE, run.donttest = interactive()) \n",
       "NULL"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "args(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y se ejecutan los ejemplos de la función `sample` como sigue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sample> x <- 1:12\n",
      "\n",
      "sample> # a random permutation\n",
      "sample> sample(x)\n",
      " [1]  5  7  4  1  3  8  9 12 11  6  2 10\n",
      "\n",
      "sample> # bootstrap resampling -- only if length(x) > 1 !\n",
      "sample> sample(x, replace = TRUE)\n",
      " [1]  2  6  6 12  2  6 10  8  2  7  7  1\n",
      "\n",
      "sample> # 100 Bernoulli trials\n",
      "sample> sample(c(0,1), 100, replace = TRUE)\n",
      "  [1] 1 1 1 0 1 0 0 0 0 0 1 0 1 0 1 1 1 1 0 0 1 1 1 0 1 0 1 0 0 0 1 1 1 0 1 1 1\n",
      " [38] 1 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 1 1 0 0 0 0 0 1 1 1 1 1 0 1 0 1 0 0 1 1 0\n",
      " [75] 1 0 1 1 0 0 1 0 1 1 1 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0\n",
      "\n",
      "sample> ## More careful bootstrapping --  Consider this when using sample()\n",
      "sample> ## programmatically (i.e., in your function or simulation)!\n",
      "sample> \n",
      "sample> # sample()'s surprise -- example\n",
      "sample> x <- 1:10\n",
      "\n",
      "sample>     sample(x[x >  8]) # length 2\n",
      "[1] 10  9\n",
      "\n",
      "sample>     sample(x[x >  9]) # oops -- length 10!\n",
      " [1]  3  6  1  7  8  2  9  5  4 10\n",
      "\n",
      "sample>     sample(x[x > 10]) # length 0\n",
      "integer(0)\n",
      "\n",
      "sample> ## safer version:\n",
      "sample> resample <- function(x, ...) x[sample.int(length(x), ...)]\n",
      "\n",
      "sample> resample(x[x >  8]) # length 2\n",
      "[1] 10  9\n",
      "\n",
      "sample> resample(x[x >  9]) # length 1\n",
      "[1] 10\n",
      "\n",
      "sample> resample(x[x > 10]) # length 0\n",
      "integer(0)\n",
      "\n",
      "sample> ## R 3.x.y only\n",
      "sample> sample.int(1e10, 12, replace = TRUE)\n",
      " [1] 2575566849 3514429428 2827840570 6308005517  811253583 6982960333\n",
      " [7] 9251408822 8413115991 8011349018 2787805302 7411643999 9521768691\n",
      "\n",
      "sample> sample.int(1e10, 12) # not that there is much chance of duplicates\n",
      " [1] 2078891680 9333817626 6049975312 4416776733 3467884371 3240276955\n",
      " [7] 9839126466 8630997200 7205736564 3237221598 1269177447 9814225164\n"
     ]
    }
   ],
   "source": [
    "example(sample, package='base')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para la función `tosscoin` se tiene la siguiente ayuda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<table width=\"100%\" summary=\"page for tosscoin {prob}\"><tr><td>tosscoin {prob}</td><td style=\"text-align: right;\">R Documentation</td></tr></table>\n",
       "\n",
       "<h2>Tossing a Coin</h2>\n",
       "\n",
       "<h3>Description</h3>\n",
       "\n",
       "<p>Sets up a sample space for the experiment of tossing a coin\n",
       "repeatedly with the outcomes &quot;H&quot; or &quot;T&quot;.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Usage</h3>\n",
       "\n",
       "<pre>\n",
       "tosscoin( times, makespace = FALSE )\n",
       "\n",
       "</pre>\n",
       "\n",
       "\n",
       "<h3>Arguments</h3>\n",
       "\n",
       "<table summary=\"R argblock\">\n",
       "<tr valign=\"top\"><td><code>times</code></td>\n",
       "<td>\n",
       "<p>number of tosses.</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>makespace</code></td>\n",
       "<td>\n",
       "<p>logical.</p>\n",
       "</td></tr>\n",
       "</table>\n",
       "\n",
       "\n",
       "<h3>Details</h3>\n",
       "\n",
       "<p>The function uses <code>expand.grid()</code> to generate all possible sequences of flips resulting from the\n",
       "experiment of tossing a coin.  Columns of the dataframe are denoted <code>toss1</code>, <code>toss2</code>, up to <code>tosstimes</code>,\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Value</h3>\n",
       "\n",
       "<p>A data frame, with an equally likely <code>probs</code> column if <code>makespace</code> is <code>TRUE</code>.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Author(s)</h3>\n",
       "\n",
       "<p>G. Jay Kerns <a href=\"mailto:gkerns@ysu.edu\">gkerns@ysu.edu</a>.</p>\n",
       "\n",
       "\n",
       "<h3>See Also</h3>\n",
       "\n",
       "<p><code>rolldie</code></p>\n",
       "\n",
       "\n",
       "<h3>Examples</h3>\n",
       "\n",
       "<pre>\n",
       "tosscoin(2)\n",
       "tosscoin(3, makespace = TRUE)\n",
       " </pre>\n",
       "\n",
       "<hr /><div style=\"text-align: center;\">[Package <em>prob</em> version 1.0-1 ]</div>"
      ],
      "text/latex": [
       "\\inputencoding{utf8}\n",
       "\\HeaderA{tosscoin}{Tossing a Coin}{tosscoin}\n",
       "\\keyword{misc}{tosscoin}\n",
       "%\n",
       "\\begin{Description}\\relax\n",
       "Sets up a sample space for the experiment of tossing a coin\n",
       "repeatedly with the outcomes \"H\" or \"T\".\n",
       "\\end{Description}\n",
       "%\n",
       "\\begin{Usage}\n",
       "\\begin{verbatim}\n",
       "tosscoin( times, makespace = FALSE )\n",
       "\n",
       "\\end{verbatim}\n",
       "\\end{Usage}\n",
       "%\n",
       "\\begin{Arguments}\n",
       "\\begin{ldescription}\n",
       "\\item[\\code{times}] number of tosses.\n",
       "\\item[\\code{makespace}] logical.\n",
       "\\end{ldescription}\n",
       "\\end{Arguments}\n",
       "%\n",
       "\\begin{Details}\\relax\n",
       "The function uses \\code{expand.grid()} to generate all possible sequences of flips resulting from the\n",
       "experiment of tossing a coin.  Columns of the dataframe are denoted \\code{toss1}, \\code{toss2}, up to \\code{tosstimes},\n",
       "\\end{Details}\n",
       "%\n",
       "\\begin{Value}\n",
       "A data frame, with an equally likely \\code{probs} column if \\code{makespace} is \\code{TRUE}.\n",
       "\\end{Value}\n",
       "%\n",
       "\\begin{Author}\\relax\n",
       "G. Jay Kerns \\email{gkerns@ysu.edu}.\n",
       "\\end{Author}\n",
       "%\n",
       "\\begin{SeeAlso}\\relax\n",
       "\\code{\\LinkA{rolldie}{rolldie}}\n",
       "\\end{SeeAlso}\n",
       "%\n",
       "\\begin{Examples}\n",
       "\\begin{ExampleCode}\n",
       "tosscoin(2)\n",
       "tosscoin(3, makespace = TRUE)\n",
       " \n",
       "\\end{ExampleCode}\n",
       "\\end{Examples}"
      ],
      "text/plain": [
       "tosscoin                 package:prob                  R Documentation\n",
       "\n",
       "_\bT_\bo_\bs_\bs_\bi_\bn_\bg _\ba _\bC_\bo_\bi_\bn\n",
       "\n",
       "_\bD_\be_\bs_\bc_\br_\bi_\bp_\bt_\bi_\bo_\bn:\n",
       "\n",
       "     Sets up a sample space for the experiment of tossing a coin\n",
       "     repeatedly with the outcomes \"H\" or \"T\".\n",
       "\n",
       "_\bU_\bs_\ba_\bg_\be:\n",
       "\n",
       "     tosscoin( times, makespace = FALSE )\n",
       "     \n",
       "_\bA_\br_\bg_\bu_\bm_\be_\bn_\bt_\bs:\n",
       "\n",
       "   times: number of tosses.\n",
       "\n",
       "makespace: logical.\n",
       "\n",
       "_\bD_\be_\bt_\ba_\bi_\bl_\bs:\n",
       "\n",
       "     The function uses ‘expand.grid()’ to generate all possible\n",
       "     sequences of flips resulting from the experiment of tossing a\n",
       "     coin.  Columns of the dataframe are denoted ‘toss1’, ‘toss2’, up\n",
       "     to ‘tosstimes’,\n",
       "\n",
       "_\bV_\ba_\bl_\bu_\be:\n",
       "\n",
       "     A data frame, with an equally likely ‘probs’ column if ‘makespace’\n",
       "     is ‘TRUE’.\n",
       "\n",
       "_\bA_\bu_\bt_\bh_\bo_\br(_\bs):\n",
       "\n",
       "     G. Jay Kerns <email: gkerns@ysu.edu>.\n",
       "\n",
       "_\bS_\be_\be _\bA_\bl_\bs_\bo:\n",
       "\n",
       "     ‘rolldie’\n",
       "\n",
       "_\bE_\bx_\ba_\bm_\bp_\bl_\be_\bs:\n",
       "\n",
       "     tosscoin(2)\n",
       "     tosscoin(3, makespace = TRUE)\n",
       "     "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?tosscoin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Para saber más sobre *R*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ir a la documentación oficial: https://cran.r-project.org/doc/manuals/R-intro.html\n",
    "* Ir [aquí](https://github.com/ITAM-DS/Propedeutico/tree/main/R) para más referencias sobre *R*.\n",
    "\n",
    "Sobre paquetes:\n",
    "* En [Bioconductor](https://www.bioconductor.org/) (y otros repositorios) encontrarás paquetes que no están en [CRAN](https://cran.r-project.org/).\n",
    "* La mejor manera de conocer qué hace y usar un paquete es ir a su documentación oficial y seguir un tutorial o *vignette*.\n",
    "\n",
    "```\n",
    "#vignette() muestra documentación de todos los paquetes instalados\n",
    "vignette('prob') #muestra documentación del paquete prob\n",
    "```\n",
    "\n",
    "* Para instalación de paquetes desde diferentes fuentes (incluyendo CRAN y otros repositorios) dar click en [devtools](https://devtools.r-lib.org/) que es una colección de herramientas para desarrollo de paquetes (pero también tiene funcionalidad para instalación de paquetes) y su correspondiente [Package Development:: Cheat Sheet](https://rawgit.com/rstudio/cheatsheets/master/package-development.pdf).\n",
    "\n",
    "* Para buscar paquetes que fueron instalados usar:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "R Information\n",
       "\n",
       "Vignettes with name or keyword or title matching ‘prob’ using regular\n",
       "expression matching:\n",
       "\n",
       "\n",
       "prob::prob              Elementary Probability on Finite Sample Spaces\n",
       "  Concepts: probability\n",
       "\n",
       "\n",
       "Type 'vignette(\"FOO\", package=\"PKG\")' to inspect entries 'PKG::FOO'.\n",
       "\n",
       "\n",
       "\n",
       "Help files with alias or concept or title matching ‘prob’ using regular\n",
       "expression matching:\n",
       "\n",
       "\n",
       "base::Random            Random Number Generation\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "base::Random.user       User-supplied Random Number Generation\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "base::sample            Random Samples and Permutations\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "boot::Imp.Estimates     Importance Sampling Estimates\n",
       "  Aliases: imp.prob\n",
       "boot::print.simplex     Print Solution to Linear Programming Problem\n",
       "boot::simplex           Simplex Method for Linear Programming Problems\n",
       "broom::augment.mfx      Augment data with information from a(n) mfx\n",
       "                        object\n",
       "  Aliases: augment.probitmfx\n",
       "broom::glance.mfx       Glance at a(n) mfx object\n",
       "  Aliases: glance.probitmfx\n",
       "broom::tidy.mfx         Tidy a(n) mfx object\n",
       "  Aliases: tidy.probitmfx\n",
       "codetools::checkUsage   Check R Code for Possible Problems\n",
       "fBasics::dght           Generalized Hyperbolic Student-t\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::distCheck      Distribution Check\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::DistributionFits\n",
       "                        Parameter Fit of a Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::gh             Generalized Hyperbolic Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ghFit          GH Distribution Fit\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ghMode         Generalized Hyperbolic Mode\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ghMoments      Generalized Hyperbolic Distribution Moments\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ghRobMoments   Robust Moments for the GH\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ghSlider       Generalized Hyperbolic Distribution Slider\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ghtFit         GHT Distribution Fit\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ghtMode        Generalized Hyperbolic Student-t Mode\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ghtMoments     Generalized Hyperbolic Student-t Moments\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ghtRobMoments\n",
       "                        Robust Moments for the GHT\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::gld            Generalized Lambda Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::gldFit         GH Distribution Fit\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::gldRobMoments\n",
       "                        Robust Moments for the GLD\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::hyp            Hyperbolic Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::hypFit         Fit of a Hyperbolic Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::hypMode        Hyperbolic Mode\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::hypMoments     Hyperbolic Distribution Moments\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::hypRobMoments\n",
       "                        Robust Moments for the HYP\n",
       "  Aliases: hypRobMoments\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::hypSlider      Hyperbolic Distribution Slider\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::maxdd          Drawdown Statistics\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::nig            Normal Inverse Gaussian Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::nigFit         Fit of a Normal Inverse Gaussian Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::nigMode        Normal Inverse Gaussian Mode\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::nigMoments     Moments for the Normal Inverse Gaussian\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::nigRobMoments\n",
       "                        Robust Moments for the NIG\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::nigShapeTriangle\n",
       "                        NIG Shape Triangle\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::nigSlider      nigerbolic Distribution Slider\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::normRobMoments\n",
       "                        Robust Moments for the NORM\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::sampleLMoments\n",
       "                        Sample L-Moments\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::sampleRobMoments\n",
       "                        Robust Moments for the GLD\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::sgh            Standardized Generalized Hyperbolic\n",
       "                        Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::sghFit         Standardized GH Distribution Fit\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::sght           Standardized generalized hyperbolic Student-t\n",
       "                        Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::snig           Standardized Normal Inverse Gaussian\n",
       "                        Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::snigFit        Fit of a Stndardized NIG Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ssd            Spline Smoothed Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::ssdFit         Fit Density Using Smoothing Splines\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "fBasics::stableSlider   Slider GUI for Stable Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "graphics::hist          Histograms\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "graphics::stem          Stem-and-Leaf Plots\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::cdsscden           Evaluating Conditional PDF, CDF, and Quantiles\n",
       "                        of Smoothing Spline Conditional Density\n",
       "                        Estimates\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::cdsscopu           Evaluating 1-D Conditional PDF, CDF, and\n",
       "                        Quantiles of Copula Density Estimates\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::cdssden            Evaluating Conditional PDF, CDF, and Quantiles\n",
       "                        of Smoothing Spline Density Estimates\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::dsscden            Evaluating PDF, CDF, and Quantiles of Smoothing\n",
       "                        Spline Conditional Density Estimates\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::dsscopu            Evaluating Copula Density Estimates\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::dssden             Evaluating PDF, CDF, and Quantiles of Smoothing\n",
       "                        Spline Density Estimates\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::sscden             Estimating Conditional Probability Density\n",
       "                        Using Smoothing Splines\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::sscopu             Estimating Copula Density Using Smoothing\n",
       "                        Splines\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::ssden              Estimating Probability Density Using Smoothing\n",
       "                        Splines\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "gss::summary.sscopu     Calculating Kendall's Tau and Spearman's Rho\n",
       "                        for 2-D Copula Density Estimates\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "httr::httr_dr           Diagnose common configuration problems\n",
       "KernSmooth::bkde        Compute a Binned Kernel Density Estimate\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "KernSmooth::bkde2D      Compute a 2D Binned Kernel Density Estimate\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "knitr::clean_cache      Clean cache files that are probably no longer\n",
       "                        needed\n",
       "MASS::fitdistr          Maximum-likelihood Fitting of Univariate\n",
       "                        Distributions\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "MASS::mvrnorm           Simulate from a Multivariate Normal\n",
       "                        Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "MASS::polr              Ordered Logistic or Probit Regression\n",
       "MASS::rnegbin           Simulate Negative Binomial Variates\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "MASS::shuttle           Space Shuttle Autolander Problem\n",
       "MASS::synth.tr          Synthetic Classification Problem\n",
       "Matrix::rsparsematrix   Random Sparse Matrix\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "parallel::nextRNGStream\n",
       "                        Implementation of Pierre L'Ecuyer's RngStreams\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "prob::addrv             Adding Random Variables to a Probability Space\n",
       "prob::cfbeta            Characteristic functions\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "prob::is.probspace      Testing for a Probability Space\n",
       "  Aliases: is.probspace\n",
       "prob::noorder           Sort and Merge Probability Space Outcomes\n",
       "prob::prob              Probability and Conditional Probability\n",
       "  Aliases: prob, Prob, Prob.default, Prob.ps\n",
       "prob::prob-package      Elementary Probability on Finite Sample Spaces\n",
       "  Aliases: prob-package\n",
       "prob::probspace         Probability Spaces\n",
       "  Aliases: probspace, probspace.default, probspace.list\n",
       "prob::subset            Subsets of Probability Spaces\n",
       "readr::problems         Retrieve parsing problems\n",
       "  Aliases: problems, stop_for_problems\n",
       "scales::probability_trans\n",
       "                        Probability transformation\n",
       "  Aliases: probability_trans, probit_trans\n",
       "stabledist::StableDistribution\n",
       "                        Stable Distribution Function\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stabledist::stableMode\n",
       "                        Mode of the Stable Distribution Function\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Beta             The Beta Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Binomial         The Binomial Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::bw.nrd0          Bandwidth Selectors for Kernel Density\n",
       "                        Estimation\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Cauchy           The Cauchy Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::chisq.test       Pearson's Chi-squared Test for Count Data\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Chisquare        The (non-central) Chi-Squared Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::density          Kernel Density Estimation\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::distribution     Distributions in the stats package\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Exponential      The Exponential Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::FDist            The F Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::fivenum          Tukey Five-Number Summaries\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::GammaDist        The Gamma Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Geometric        The Geometric Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Hypergeometric   The Hypergeometric Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::IQR              The Interquartile Range\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Logistic         The Logistic Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Lognormal        The Log Normal Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Multinomial      The Multinomial Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::NegBinomial      The Negative Binomial Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Normal           The Normal Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Poisson          The Poisson Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::ppoints          Ordinates for Probability Plotting\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::qbirthday        Probability of coincidences\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::qqnorm           Quantile-Quantile Plots\n",
       "  Concepts: normal probability plot, Probability Distributions and\n",
       "    Random Numbers\n",
       "stats::r2dtable         Random 2-way Tables with Given Marginals\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::SignRank         Distribution of the Wilcoxon Signed Rank\n",
       "                        Statistic\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::TDist            The Student t Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Tukey            The Studentized Range Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Uniform          The Uniform Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Weibull          The Weibull Distribution\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "stats::Wilcoxon         Distribution of the Wilcoxon Rank Sum Statistic\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "survival::blogit        Bounded link functions\n",
       "  Aliases: bprobit\n",
       "survival::dsurvreg      Distributions available in survreg.\n",
       "  Concepts: Probability Distributions and Random Numbers\n",
       "testthat::CheckReporter\n",
       "                        Check reporter: 13 line summary of problems\n",
       "\n",
       "\n",
       "Type '?PKG::FOO' to inspect entries 'PKG::FOO', or 'TYPE?PKG::FOO' for\n",
       "entries like 'PKG::FOO-TYPE'.\n",
       "\n",
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "help.search(\"prob\") #or: ??prob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sobre funciones para encontrar objetos:\n",
    "\n",
    "* La función `apropos` también ayuda a encontrar objetos. Nos devuelve objetos (incluídas funciones) en la sesión actual de *R* que tienen nombres que incluyen un *string* en específico.  Por ejemplo en la siguiente ejecución obtenemos los objetos que tienen el nombre `union`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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>'isClassUnion'</li><li>'Reunion'</li><li>'setClassUnion'</li><li>'ts.union'</li><li>'union'</li><li>'union'</li><li>'union.data.frame'</li><li>'union.default'</li><li>'union.ps'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'isClassUnion'\n",
       "\\item 'Reunion'\n",
       "\\item 'setClassUnion'\n",
       "\\item 'ts.union'\n",
       "\\item 'union'\n",
       "\\item 'union'\n",
       "\\item 'union.data.frame'\n",
       "\\item 'union.default'\n",
       "\\item 'union.ps'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'isClassUnion'\n",
       "2. 'Reunion'\n",
       "3. 'setClassUnion'\n",
       "4. 'ts.union'\n",
       "5. 'union'\n",
       "6. 'union'\n",
       "7. 'union.data.frame'\n",
       "8. 'union.default'\n",
       "9. 'union.ps'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"isClassUnion\"     \"Reunion\"          \"setClassUnion\"    \"ts.union\"        \n",
       "[5] \"union\"            \"union\"            \"union.data.frame\" \"union.default\"   \n",
       "[9] \"union.ps\"        "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "apropos(\"union\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sobre `apropos` y cómo buscar ayuda en *R* [Getting Help with R](https://www.r-project.org/help.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función de `library` también nos proporciona ayuda de un paquete:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Documentation for package ‘prob’\n",
       "\n",
       "\n",
       "\t\tInformation on package ‘prob’\n",
       "\n",
       "Description:\n",
       "\n",
       "Package:                            prob\n",
       "Version:                            1.0-1\n",
       "Date:                               2018-08-27\n",
       "Title:                              Elementary Probability on Finite\n",
       "                                    Sample Spaces\n",
       "Authors@R:                          person(given = \"G. Jay\", family =\n",
       "                                    \"Kerns\", role = c(\"aut\", \"cre\",\n",
       "                                    \"cph\"), email = \"gkerns@ysu.edu\")\n",
       "Depends:                            combinat, fAsianOptions\n",
       "Suggests:                           VGAM, reshape, MASS, hypergeo\n",
       "Description:                        A framework for performing\n",
       "                                    elementary probability calculations\n",
       "                                    on finite sample spaces, which may\n",
       "                                    be represented by data frames or\n",
       "                                    lists.  Functionality includes\n",
       "                                    setting up sample spaces, counting\n",
       "                                    tools, defining probability spaces,\n",
       "                                    performing set algebra, calculating\n",
       "                                    probability and conditional\n",
       "                                    probability, tools for simulation\n",
       "                                    and checking the law of large\n",
       "                                    numbers, adding random variables,\n",
       "                                    and finding marginal distributions.\n",
       "                                    Characteristic functions for all\n",
       "                                    base R distributions are included.\n",
       "License:                            GPL (>= 3)\n",
       "URL:                                http://prob.r-forge.r-project.org,\n",
       "                                    http://gkerns.people.ysu.edu/\n",
       "Author:                             G. Jay Kerns [aut, cre, cph]\n",
       "Maintainer:                         G. Jay Kerns <gkerns@ysu.edu>\n",
       "Repository:                         CRAN\n",
       "Repository/R-Forge/Project:         prob\n",
       "Repository/R-Forge/Revision:        51\n",
       "Repository/R-Forge/DateTimeStamp:   2018-08-27 16:33:32\n",
       "Date/Publication:                   2018-08-27 19:20:03 UTC\n",
       "NeedsCompilation:                   no\n",
       "Packaged:                           2018-08-27 16:50:38 UTC; rforge\n",
       "Built:                              R 4.1.0; ; 2021-05-30 19:08:55 UTC;\n",
       "                                    unix\n",
       "\n",
       "Index:\n",
       "\n",
       "addrv                   Adding Random Variables to a Probability Space\n",
       "cards                   A Standard Set of Playing Cards\n",
       "cfbeta                  Characteristic functions\n",
       "countrep                Count Repetitions\n",
       "empirical               Empirical Summary of a Simulation\n",
       "euchredeck              A Deck of Playing Cards for Euchre\n",
       "gen2wayTable            Generate Two-way Tables\n",
       "genIndepTable           Generate Independent Two-way Table\n",
       "genLogRegData           Generate data for logistic regression\n",
       "genXdata                Generate continuous model matrix data\n",
       "iidspace                Independent Identical Experiments\n",
       "intersect               Intersection of Subsets\n",
       "is.probspace            Testing for a Probability Space\n",
       "isin                    Test Whether One Vector Is In Another Vector\n",
       "isrep                   Is Repeated in a Vector\n",
       "marginal                Marginal Distributions\n",
       "noorder                 Sort and Merge Probability Space Outcomes\n",
       "nsamp                   Number of Samples from an Urn\n",
       "permsn                  Generate All Permutations of x Elements Taken m\n",
       "                        at a Time\n",
       "prob                    Probability and Conditional Probability\n",
       "prob-package            Elementary Probability on Finite Sample Spaces\n",
       "probspace               Probability Spaces\n",
       "rolldie                 Rolling a Die\n",
       "roulette                Roulette\n",
       "setdiff                 Set Difference of Subsets\n",
       "sim                     Simulate Draws from a Sample Space\n",
       "subset                  Subsets of Probability Spaces\n",
       "tosscoin                Tossing a Coin\n",
       "union                   Union of Subsets\n",
       "urnsamples              Sampling from Urns\n",
       "\n",
       "Further information is available in the following vignettes in\n",
       "directory ‘/usr/local/lib/R/site-library/prob/doc’:\n",
       "\n",
       "charfunc: Characteristic Functions (source, pdf)\n",
       "prob: Elementary Probability on Finite Sample Spaces (source, pdf)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "library(help=prob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<table width=\"100%\" summary=\"page for prob {prob}\"><tr><td>prob {prob}</td><td style=\"text-align: right;\">R Documentation</td></tr></table>\n",
       "\n",
       "<h2>Probability and Conditional Probability</h2>\n",
       "\n",
       "<h3>Description</h3>\n",
       "\n",
       "<p>Calculates probability and conditional probability of events.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Usage</h3>\n",
       "\n",
       "<pre>\n",
       "Prob(x, ...)\n",
       "\n",
       "## Default S3 method:\n",
       "Prob(x, event = NULL, given = NULL, ...)\n",
       "\n",
       "## S3 method for class 'ps'\n",
       "Prob(x, event = NULL, given = NULL, ...)\n",
       "</pre>\n",
       "\n",
       "\n",
       "<h3>Arguments</h3>\n",
       "\n",
       "<table summary=\"R argblock\">\n",
       "<tr valign=\"top\"><td><code>x</code></td>\n",
       "<td>\n",
       "<p>a probability space or a subset of one.</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>event</code></td>\n",
       "<td>\n",
       "<p>logical expression indicating elements or rows of <code>space</code> to keep:\n",
       "missing values are taken as false.</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>given</code></td>\n",
       "<td>\n",
       "<p>either a subset of a probability space or a logical expression indicating elements or rows of <code>space</code> to keep:\n",
       "missing values are taken as false.</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>...</code></td>\n",
       "<td>\n",
       "<p>further arguments to be passed to or from other methods.</p>\n",
       "</td></tr>\n",
       "</table>\n",
       "\n",
       "\n",
       "<h3>Details</h3>\n",
       "\n",
       "<p>This function calculates the probability of events or subsets of a given sample space.\n",
       "Conditional probability is also implemented.  In essence, the <code>Prob()</code> function operates by summing the <code>probs</code> column of its argument.  It will find subsets on the fly if desired.  \n",
       "</p>\n",
       "<p>The <code>event</code> argument is used to define a subset of <code>x</code>, that is, the only outcomes used in the probability calculation will be those that are elements of <code>x</code> and satisfy <code>event</code> simultaneously. In other words, <code>Prob(x,event)</code> calculates <code>Prob(intersect(x, subset(x, event)))</code>.  Consequently, <code>x</code> should be the entire probability space in the case that <code>event</code> is non-null.\n",
       "</p>\n",
       "<p>There is some flexibility in the <code>given</code> argument in that it can be either a data frame or it can be a logical expression that defines the subset.  However, that flexibility is limited.  In particular, if <code>given</code> is a logical expression, then <code>event</code> must also be specified (also a logical expression).  And in this case, the argument <code>x</code> should be the entire sample space, not a subset thereof. \n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Value</h3>\n",
       "\n",
       "<p>A number in the interval <code>[0,1]</code>.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Author(s)</h3>\n",
       "\n",
       "<p>G. Jay Kerns <a href=\"mailto:gkerns@ysu.edu\">gkerns@ysu.edu</a>.</p>\n",
       "\n",
       "\n",
       "<h3>See Also</h3>\n",
       "\n",
       "<p><code>probspace</code>, <code>iidspace</code></p>\n",
       "\n",
       "\n",
       "<h3>Examples</h3>\n",
       "\n",
       "<pre>\n",
       "S &lt;- rolldie(times = 3, makespace = TRUE )\n",
       "Prob(S, X1+X2 &gt; 9 )\n",
       "Prob(S, X1+X2 &gt; 9, given = X1+X2+X3 &gt; 7 )\n",
       "</pre>\n",
       "\n",
       "<hr /><div style=\"text-align: center;\">[Package <em>prob</em> version 1.0-1 ]</div>"
      ],
      "text/latex": [
       "\\inputencoding{utf8}\n",
       "\\HeaderA{prob}{Probability and Conditional Probability}{prob}\n",
       "\\aliasA{Prob}{prob}{Prob}\n",
       "\\methaliasA{Prob.default}{prob}{Prob.default}\n",
       "\\methaliasA{Prob.ps}{prob}{Prob.ps}\n",
       "\\keyword{misc}{prob}\n",
       "%\n",
       "\\begin{Description}\\relax\n",
       "Calculates probability and conditional probability of events.\n",
       "\\end{Description}\n",
       "%\n",
       "\\begin{Usage}\n",
       "\\begin{verbatim}\n",
       "Prob(x, ...)\n",
       "\n",
       "## Default S3 method:\n",
       "Prob(x, event = NULL, given = NULL, ...)\n",
       "\n",
       "## S3 method for class 'ps'\n",
       "Prob(x, event = NULL, given = NULL, ...)\n",
       "\\end{verbatim}\n",
       "\\end{Usage}\n",
       "%\n",
       "\\begin{Arguments}\n",
       "\\begin{ldescription}\n",
       "\\item[\\code{x}] a probability space or a subset of one.\n",
       "\\item[\\code{event}] logical expression indicating elements or rows of \\code{space} to keep:\n",
       "missing values are taken as false.\n",
       "\\item[\\code{given}] either a subset of a probability space or a logical expression indicating elements or rows of \\code{space} to keep:\n",
       "missing values are taken as false.\n",
       "\\item[\\code{...}] further arguments to be passed to or from other methods.\n",
       "\\end{ldescription}\n",
       "\\end{Arguments}\n",
       "%\n",
       "\\begin{Details}\\relax\n",
       "This function calculates the probability of events or subsets of a given sample space.\n",
       "Conditional probability is also implemented.  In essence, the \\code{Prob()} function operates by summing the \\code{probs} column of its argument.  It will find subsets on the fly if desired.  \n",
       "\n",
       "The \\code{event} argument is used to define a subset of \\code{x}, that is, the only outcomes used in the probability calculation will be those that are elements of \\code{x} and satisfy \\code{event} simultaneously. In other words, \\code{Prob(x,event)} calculates \\code{Prob(intersect(x, subset(x, event)))}.  Consequently, \\code{x} should be the entire probability space in the case that \\code{event} is non-null.\n",
       "\n",
       "There is some flexibility in the \\code{given} argument in that it can be either a data frame or it can be a logical expression that defines the subset.  However, that flexibility is limited.  In particular, if \\code{given} is a logical expression, then \\code{event} must also be specified (also a logical expression).  And in this case, the argument \\code{x} should be the entire sample space, not a subset thereof. \n",
       "\\end{Details}\n",
       "%\n",
       "\\begin{Value}\n",
       "A number in the interval \\code{[0,1]}.\n",
       "\\end{Value}\n",
       "%\n",
       "\\begin{Author}\\relax\n",
       "G. Jay Kerns \\email{gkerns@ysu.edu}.\n",
       "\\end{Author}\n",
       "%\n",
       "\\begin{SeeAlso}\\relax\n",
       "\\code{\\LinkA{probspace}{probspace}}, \\code{\\LinkA{iidspace}{iidspace}}\n",
       "\\end{SeeAlso}\n",
       "%\n",
       "\\begin{Examples}\n",
       "\\begin{ExampleCode}\n",
       "S <- rolldie(times = 3, makespace = TRUE )\n",
       "Prob(S, X1+X2 > 9 )\n",
       "Prob(S, X1+X2 > 9, given = X1+X2+X3 > 7 )\n",
       "\\end{ExampleCode}\n",
       "\\end{Examples}"
      ],
      "text/plain": [
       "prob                   package:prob                    R Documentation\n",
       "\n",
       "_\bP_\br_\bo_\bb_\ba_\bb_\bi_\bl_\bi_\bt_\by _\ba_\bn_\bd _\bC_\bo_\bn_\bd_\bi_\bt_\bi_\bo_\bn_\ba_\bl _\bP_\br_\bo_\bb_\ba_\bb_\bi_\bl_\bi_\bt_\by\n",
       "\n",
       "_\bD_\be_\bs_\bc_\br_\bi_\bp_\bt_\bi_\bo_\bn:\n",
       "\n",
       "     Calculates probability and conditional probability of events.\n",
       "\n",
       "_\bU_\bs_\ba_\bg_\be:\n",
       "\n",
       "     Prob(x, ...)\n",
       "     \n",
       "     ## Default S3 method:\n",
       "     Prob(x, event = NULL, given = NULL, ...)\n",
       "     \n",
       "     ## S3 method for class 'ps'\n",
       "     Prob(x, event = NULL, given = NULL, ...)\n",
       "     \n",
       "_\bA_\br_\bg_\bu_\bm_\be_\bn_\bt_\bs:\n",
       "\n",
       "       x: a probability space or a subset of one.\n",
       "\n",
       "   event: logical expression indicating elements or rows of ‘space’ to\n",
       "          keep: missing values are taken as false.\n",
       "\n",
       "   given: either a subset of a probability space or a logical\n",
       "          expression indicating elements or rows of ‘space’ to keep:\n",
       "          missing values are taken as false.\n",
       "\n",
       "     ...: further arguments to be passed to or from other methods.\n",
       "\n",
       "_\bD_\be_\bt_\ba_\bi_\bl_\bs:\n",
       "\n",
       "     This function calculates the probability of events or subsets of a\n",
       "     given sample space.  Conditional probability is also implemented.\n",
       "     In essence, the ‘Prob()’ function operates by summing the ‘probs’\n",
       "     column of its argument.  It will find subsets on the fly if\n",
       "     desired.\n",
       "\n",
       "     The ‘event’ argument is used to define a subset of ‘x’, that is,\n",
       "     the only outcomes used in the probability calculation will be\n",
       "     those that are elements of ‘x’ and satisfy ‘event’ simultaneously.\n",
       "     In other words, ‘Prob(x,event)’ calculates ‘Prob(intersect(x,\n",
       "     subset(x, event)))’.  Consequently, ‘x’ should be the entire\n",
       "     probability space in the case that ‘event’ is non-null.\n",
       "\n",
       "     There is some flexibility in the ‘given’ argument in that it can\n",
       "     be either a data frame or it can be a logical expression that\n",
       "     defines the subset.  However, that flexibility is limited.  In\n",
       "     particular, if ‘given’ is a logical expression, then ‘event’ must\n",
       "     also be specified (also a logical expression).  And in this case,\n",
       "     the argument ‘x’ should be the entire sample space, not a subset\n",
       "     thereof.\n",
       "\n",
       "_\bV_\ba_\bl_\bu_\be:\n",
       "\n",
       "     A number in the interval ‘[0,1]’.\n",
       "\n",
       "_\bA_\bu_\bt_\bh_\bo_\br(_\bs):\n",
       "\n",
       "     G. Jay Kerns <email: gkerns@ysu.edu>.\n",
       "\n",
       "_\bS_\be_\be _\bA_\bl_\bs_\bo:\n",
       "\n",
       "     ‘probspace’, ‘iidspace’\n",
       "\n",
       "_\bE_\bx_\ba_\bm_\bp_\bl_\be_\bs:\n",
       "\n",
       "     S <- rolldie(times = 3, makespace = TRUE )\n",
       "     Prob(S, X1+X2 > 9 )\n",
       "     Prob(S, X1+X2 > 9, given = X1+X2+X3 > 7 )\n",
       "     "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "R version 4.1.0 (2021-05-18)\n",
       "Platform: x86_64-pc-linux-gnu (64-bit)\n",
       "Running under: Ubuntu 20.04.2 LTS\n",
       "\n",
       "Matrix products: default\n",
       "BLAS:   /usr/lib/x86_64-linux-gnu/blas/libblas.so.3.9.0\n",
       "LAPACK: /usr/lib/x86_64-linux-gnu/lapack/liblapack.so.3.9.0\n",
       "\n",
       "locale:\n",
       " [1] LC_CTYPE=C.UTF-8       LC_NUMERIC=C           LC_TIME=C.UTF-8       \n",
       " [4] LC_COLLATE=C.UTF-8     LC_MONETARY=C.UTF-8    LC_MESSAGES=C.UTF-8   \n",
       " [7] LC_PAPER=C.UTF-8       LC_NAME=C              LC_ADDRESS=C          \n",
       "[10] LC_TELEPHONE=C         LC_MEASUREMENT=C.UTF-8 LC_IDENTIFICATION=C   \n",
       "\n",
       "attached base packages:\n",
       "[1] stats     graphics  grDevices utils     datasets  methods   base     \n",
       "\n",
       "other attached packages:\n",
       "[1] prob_1.0-1            fAsianOptions_3042.82 fOptions_3042.86     \n",
       "[4] fBasics_3042.89.1     timeSeries_3062.100   timeDate_3043.102    \n",
       "[7] combinat_0.0-8       \n",
       "\n",
       "loaded via a namespace (and not attached):\n",
       " [1] fansi_0.5.0         digest_0.6.27       utf8_1.2.1         \n",
       " [4] crayon_1.4.1        IRdisplay_1.0       repr_1.1.3         \n",
       " [7] lifecycle_1.0.0     jsonlite_1.7.2      evaluate_0.14      \n",
       "[10] pillar_1.6.1        rlang_0.4.11        spatial_7.3-11     \n",
       "[13] uuid_0.1-4          vctrs_0.3.8         ellipsis_0.3.2     \n",
       "[16] IRkernel_1.2.0.9000 tools_4.1.0         compiler_4.1.0     \n",
       "[19] base64enc_0.1-3     pbdZMQ_0.3-5        htmltools_0.5.1.1  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sessionInfo()"
   ]
  }
 ],
 "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.2.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}