02_r.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# R Examples\n",
    "\n",
    "Many of the things we saw with Python have R equivalents.\n",
    "\n",
    "## Ints and floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Though = tends to work, we use <- for assignment by convention.\n",
    "a <- 2\n",
    "b <- 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "5"
      ],
      "text/latex": [
       "5"
      ],
      "text/markdown": [
       "5"
      ],
      "text/plain": [
       "[1] 5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "-1"
      ],
      "text/latex": [
       "-1"
      ],
      "text/markdown": [
       "-1"
      ],
      "text/plain": [
       "[1] -1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "8"
      ],
      "text/latex": [
       "8"
      ],
      "text/markdown": [
       "8"
      ],
      "text/plain": [
       "[1] 8"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a ** b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "0.666666666666667"
      ],
      "text/latex": [
       "0.666666666666667"
      ],
      "text/markdown": [
       "0.666666666666667"
      ],
      "text/plain": [
       "[1] 0.6666667"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a / b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "0"
      ],
      "text/latex": [
       "0"
      ],
      "text/markdown": [
       "0"
      ],
      "text/plain": [
       "[1] 0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Note the different int division operator.\n",
    "a %/% b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Again, it's similar\n",
    "a_string <- 'Hello!'\n",
    "b_string <- \"Good way to contain 'single' quotes.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'Hello!'"
      ],
      "text/latex": [
       "'Hello!'"
      ],
      "text/markdown": [
       "'Hello!'"
      ],
      "text/plain": [
       "[1] \"Hello!\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'Good way to contain \\'single\\' quotes.'"
      ],
      "text/latex": [
       "'Good way to contain \\textbackslash{}'single\\textbackslash{}' quotes.'"
      ],
      "text/markdown": [
       "'Good way to contain \\'single\\' quotes.'"
      ],
      "text/plain": [
       "[1] \"Good way to contain 'single' quotes.\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Note that the string contains backslashes for escaping the quotes.\n",
    "b_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists and sort-of dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note the c() function for creating lists.\n",
    "a_list <- c('Lists', 'are', 'quite', 'helpful')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>'Lists'</li>\n",
       "\t<li>'are'</li>\n",
       "\t<li>'quite'</li>\n",
       "\t<li>'helpful'</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'Lists'\n",
       "\\item 'are'\n",
       "\\item 'quite'\n",
       "\\item 'helpful'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'Lists'\n",
       "2. 'are'\n",
       "3. 'quite'\n",
       "4. 'helpful'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"Lists\"   \"are\"     \"quite\"   \"helpful\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<dl class=dl-horizontal>\n",
       "\t<dt>A</dt>\n",
       "\t\t<dd>1</dd>\n",
       "\t<dt>B</dt>\n",
       "\t\t<dd>2</dd>\n",
       "\t<dt>C</dt>\n",
       "\t\t<dd>3</dd>\n",
       "</dl>\n"
      ],
      "text/latex": [
       "\\begin{description*}\n",
       "\\item[A] 1\n",
       "\\item[B] 2\n",
       "\\item[C] 3\n",
       "\\end{description*}\n"
      ],
      "text/markdown": [
       "A\n",
       ":   1B\n",
       ":   2C\n",
       ":   3\n",
       "\n"
      ],
      "text/plain": [
       "A B C \n",
       "1 2 3 "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Rough equivalent of a dictionary\n",
    "a_dict <- c(1, 2, 3)\n",
    "names(a_dict) <- c('A', 'B', 'C')\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## We tend to use functions instead of methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'MY CAPS LOCK KEY IS BROKEN, APPARENTLY.'"
      ],
      "text/latex": [
       "'MY CAPS LOCK KEY IS BROKEN, APPARENTLY.'"
      ],
      "text/markdown": [
       "'MY CAPS LOCK KEY IS BROKEN, APPARENTLY.'"
      ],
      "text/plain": [
       "[1] \"MY CAPS LOCK KEY IS BROKEN, APPARENTLY.\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c_string <- 'MY CAPS LOCK KEY IS BROKEN, APPARENTLY.'\n",
    "c_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'my caps lock key is broken, apparently.'"
      ],
      "text/latex": [
       "'my caps lock key is broken, apparently.'"
      ],
      "text/markdown": [
       "'my caps lock key is broken, apparently.'"
      ],
      "text/plain": [
       "[1] \"my caps lock key is broken, apparently.\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tolower(c_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'MY CAPS LOCK KEY IS BROKEN, APPARENTLY.'"
      ],
      "text/latex": [
       "'MY CAPS LOCK KEY IS BROKEN, APPARENTLY.'"
      ],
      "text/markdown": [
       "'MY CAPS LOCK KEY IS BROKEN, APPARENTLY.'"
      ],
      "text/plain": [
       "[1] \"MY CAPS LOCK KEY IS BROKEN, APPARENTLY.\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Again, though, the underlying object hasn't changed.\n",
    "c_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing documentation\n",
    "\n",
    "While the [manual](https://cran.r-project.org/doc/manuals/r-release/R-intro.html) is freely available on the web, the aptly-named `help()` function is useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<table width=\"100%\" summary=\"page for chartr {base}\"><tr><td>chartr {base}</td><td style=\"text-align: right;\">R Documentation</td></tr></table>\n",
       "\n",
       "<h2>Character Translation and Casefolding</h2>\n",
       "\n",
       "<h3>Description</h3>\n",
       "\n",
       "<p>Translate characters in character vectors, in particular from upper to\n",
       "lower case or vice versa.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Usage</h3>\n",
       "\n",
       "<pre>\n",
       "chartr(old, new, x)\n",
       "tolower(x)\n",
       "toupper(x)\n",
       "casefold(x, upper = FALSE)\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 character vector, or an object that can be coerced to\n",
       "character by <code>as.character</code>.</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>old</code></td>\n",
       "<td>\n",
       "<p>a character string specifying the characters to be\n",
       "translated.  If a character vector of length 2 or more is supplied,\n",
       "the first element is used with a warning.</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>new</code></td>\n",
       "<td>\n",
       "<p>a character string specifying the translations. If a\n",
       "character vector of length 2 or more is supplied, the first element\n",
       "is used with a warning.</p>\n",
       "</td></tr>\n",
       "<tr valign=\"top\"><td><code>upper</code></td>\n",
       "<td>\n",
       "<p>logical: translate to upper or lower case?.</p>\n",
       "</td></tr>\n",
       "</table>\n",
       "\n",
       "\n",
       "<h3>Details</h3>\n",
       "\n",
       "<p><code>chartr</code> translates each character in <code>x</code> that is specified\n",
       "in <code>old</code> to the corresponding character specified in <code>new</code>.\n",
       "Ranges are supported in the specifications, but character classes and\n",
       "repeated characters are not.  If <code>old</code> contains more characters\n",
       "than new, an error is signaled; if it contains fewer characters, the\n",
       "extra characters at the end of <code>new</code> are ignored.\n",
       "</p>\n",
       "<p><code>tolower</code> and <code>toupper</code> convert upper-case characters in a\n",
       "character vector to lower-case, or vice versa.  Non-alphabetic\n",
       "characters are left unchanged.\n",
       "</p>\n",
       "<p><code>casefold</code> is a wrapper for <code>tolower</code> and <code>toupper</code>\n",
       "provided for compatibility with S-PLUS.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Value</h3>\n",
       "\n",
       "<p>A character vector of the same length and with the same attributes as\n",
       "<code>x</code> (after possible coercion).\n",
       "</p>\n",
       "<p>Elements of the result will be have the encoding declared as that of\n",
       "the current locale (see <code>Encoding</code>) if the corresponding\n",
       "input had a declared encoding and the current locale is either Latin-1\n",
       "or UTF-8.  The result will be in the current locale's encoding unless\n",
       "the corresponding input was in UTF-8, when it will be in UTF-8 when\n",
       "the system has Unicode wide characters.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>See Also</h3>\n",
       "\n",
       "<p><code>sub</code> and <code>gsub</code> for other\n",
       "substitutions in strings.\n",
       "</p>\n",
       "\n",
       "\n",
       "<h3>Examples</h3>\n",
       "\n",
       "<pre>\n",
       "x &lt;- \"MiXeD cAsE 123\"\n",
       "chartr(\"iXs\", \"why\", x)\n",
       "chartr(\"a-cX\", \"D-Fw\", x)\n",
       "tolower(x)\n",
       "toupper(x)\n",
       "\n",
       "## \"Mixed Case\" Capitalizing - toupper( every first letter of a word ) :\n",
       "\n",
       ".simpleCap &lt;- function(x) {\n",
       "    s &lt;- strsplit(x, \" \")[[1]]\n",
       "    paste(toupper(substring(s, 1, 1)), substring(s, 2),\n",
       "          sep = \"\", collapse = \" \")\n",
       "}\n",
       ".simpleCap(\"the quick red fox jumps over the lazy brown dog\")\n",
       "## -&gt;  [1] \"The Quick Red Fox Jumps Over The Lazy Brown Dog\"\n",
       "\n",
       "## and the better, more sophisticated version:\n",
       "capwords &lt;- function(s, strict = FALSE) {\n",
       "    cap &lt;- function(s) paste(toupper(substring(s, 1, 1)),\n",
       "                  {s &lt;- substring(s, 2); if(strict) tolower(s) else s},\n",
       "                             sep = \"\", collapse = \" \" )\n",
       "    sapply(strsplit(s, split = \" \"), cap, USE.NAMES = !is.null(names(s)))\n",
       "}\n",
       "capwords(c(\"using AIC for model selection\"))\n",
       "## -&gt;  [1] \"Using AIC For Model Selection\"\n",
       "capwords(c(\"using AIC\", \"for MODEL selection\"), strict = TRUE)\n",
       "## -&gt;  [1] \"Using Aic\"  \"For Model Selection\"\n",
       "##                ^^^        ^^^^^\n",
       "##               'bad'       'good'\n",
       "\n",
       "## -- Very simple insecure crypto --\n",
       "rot &lt;- function(ch, k = 13) {\n",
       "   p0 &lt;- function(...) paste(c(...), collapse = \"\")\n",
       "   A &lt;- c(letters, LETTERS, \" '\")\n",
       "   I &lt;- seq_len(k); chartr(p0(A), p0(c(A[-I], A[I])), ch)\n",
       "}\n",
       "\n",
       "pw &lt;- \"my secret pass phrase\"\n",
       "(crypw &lt;- rot(pw, 13)) #-&gt; you can send this off\n",
       "\n",
       "## now ``decrypt'' :\n",
       "rot(crypw, 54 - 13) # -&gt; the original:\n",
       "stopifnot(identical(pw, rot(crypw, 54 - 13)))\n",
       "</pre>\n",
       "\n",
       "<hr /><div style=\"text-align: center;\">[Package <em>base</em> version 3.5.1 ]</div>"
      ],
      "text/latex": [
       "\\inputencoding{utf8}\n",
       "\\HeaderA{chartr}{Character Translation and Casefolding}{chartr}\n",
       "\\aliasA{casefold}{chartr}{casefold}\n",
       "\\aliasA{tolower}{chartr}{tolower}\n",
       "\\aliasA{toupper}{chartr}{toupper}\n",
       "\\keyword{character}{chartr}\n",
       "%\n",
       "\\begin{Description}\\relax\n",
       "Translate characters in character vectors, in particular from upper to\n",
       "lower case or vice versa.\n",
       "\\end{Description}\n",
       "%\n",
       "\\begin{Usage}\n",
       "\\begin{verbatim}\n",
       "chartr(old, new, x)\n",
       "tolower(x)\n",
       "toupper(x)\n",
       "casefold(x, upper = FALSE)\n",
       "\\end{verbatim}\n",
       "\\end{Usage}\n",
       "%\n",
       "\\begin{Arguments}\n",
       "\\begin{ldescription}\n",
       "\\item[\\code{x}] a character vector, or an object that can be coerced to\n",
       "character by \\code{\\LinkA{as.character}{as.character}}.\n",
       "\\item[\\code{old}] a character string specifying the characters to be\n",
       "translated.  If a character vector of length 2 or more is supplied,\n",
       "the first element is used with a warning.\n",
       "\\item[\\code{new}] a character string specifying the translations. If a\n",
       "character vector of length 2 or more is supplied, the first element\n",
       "is used with a warning.\n",
       "\\item[\\code{upper}] logical: translate to upper or lower case?.\n",
       "\\end{ldescription}\n",
       "\\end{Arguments}\n",
       "%\n",
       "\\begin{Details}\\relax\n",
       "\\code{chartr} translates each character in \\code{x} that is specified\n",
       "in \\code{old} to the corresponding character specified in \\code{new}.\n",
       "Ranges are supported in the specifications, but character classes and\n",
       "repeated characters are not.  If \\code{old} contains more characters\n",
       "than new, an error is signaled; if it contains fewer characters, the\n",
       "extra characters at the end of \\code{new} are ignored.\n",
       "\n",
       "\\code{tolower} and \\code{toupper} convert upper-case characters in a\n",
       "character vector to lower-case, or vice versa.  Non-alphabetic\n",
       "characters are left unchanged.\n",
       "\n",
       "\\code{casefold} is a wrapper for \\code{tolower} and \\code{toupper}\n",
       "provided for compatibility with S-PLUS.\n",
       "\\end{Details}\n",
       "%\n",
       "\\begin{Value}\n",
       "A character vector of the same length and with the same attributes as\n",
       "\\code{x} (after possible coercion).\n",
       "\n",
       "Elements of the result will be have the encoding declared as that of\n",
       "the current locale (see \\code{\\LinkA{Encoding}{Encoding}}) if the corresponding\n",
       "input had a declared encoding and the current locale is either Latin-1\n",
       "or UTF-8.  The result will be in the current locale's encoding unless\n",
       "the corresponding input was in UTF-8, when it will be in UTF-8 when\n",
       "the system has Unicode wide characters.\n",
       "\\end{Value}\n",
       "%\n",
       "\\begin{SeeAlso}\\relax\n",
       "\\code{\\LinkA{sub}{sub}} and \\code{\\LinkA{gsub}{gsub}} for other\n",
       "substitutions in strings.\n",
       "\\end{SeeAlso}\n",
       "%\n",
       "\\begin{Examples}\n",
       "\\begin{ExampleCode}\n",
       "x <- \"MiXeD cAsE 123\"\n",
       "chartr(\"iXs\", \"why\", x)\n",
       "chartr(\"a-cX\", \"D-Fw\", x)\n",
       "tolower(x)\n",
       "toupper(x)\n",
       "\n",
       "## \"Mixed Case\" Capitalizing - toupper( every first letter of a word ) :\n",
       "\n",
       ".simpleCap <- function(x) {\n",
       "    s <- strsplit(x, \" \")[[1]]\n",
       "    paste(toupper(substring(s, 1, 1)), substring(s, 2),\n",
       "          sep = \"\", collapse = \" \")\n",
       "}\n",
       ".simpleCap(\"the quick red fox jumps over the lazy brown dog\")\n",
       "## ->  [1] \"The Quick Red Fox Jumps Over The Lazy Brown Dog\"\n",
       "\n",
       "## and the better, more sophisticated version:\n",
       "capwords <- function(s, strict = FALSE) {\n",
       "    cap <- function(s) paste(toupper(substring(s, 1, 1)),\n",
       "                  {s <- substring(s, 2); if(strict) tolower(s) else s},\n",
       "                             sep = \"\", collapse = \" \" )\n",
       "    sapply(strsplit(s, split = \" \"), cap, USE.NAMES = !is.null(names(s)))\n",
       "}\n",
       "capwords(c(\"using AIC for model selection\"))\n",
       "## ->  [1] \"Using AIC For Model Selection\"\n",
       "capwords(c(\"using AIC\", \"for MODEL selection\"), strict = TRUE)\n",
       "## ->  [1] \"Using Aic\"  \"For Model Selection\"\n",
       "##                ^^^        ^^^^^\n",
       "##               'bad'       'good'\n",
       "\n",
       "## -- Very simple insecure crypto --\n",
       "rot <- function(ch, k = 13) {\n",
       "   p0 <- function(...) paste(c(...), collapse = \"\")\n",
       "   A <- c(letters, LETTERS, \" '\")\n",
       "   I <- seq_len(k); chartr(p0(A), p0(c(A[-I], A[I])), ch)\n",
       "}\n",
       "\n",
       "pw <- \"my secret pass phrase\"\n",
       "(crypw <- rot(pw, 13)) #-> you can send this off\n",
       "\n",
       "## now ``decrypt'' :\n",
       "rot(crypw, 54 - 13) # -> the original:\n",
       "stopifnot(identical(pw, rot(crypw, 54 - 13)))\n",
       "\\end{ExampleCode}\n",
       "\\end{Examples}"
      ],
      "text/plain": [
       "chartr                  package:base                   R Documentation\n",
       "\n",
       "_\bC_\bh_\ba_\br_\ba_\bc_\bt_\be_\br _\bT_\br_\ba_\bn_\bs_\bl_\ba_\bt_\bi_\bo_\bn _\ba_\bn_\bd _\bC_\ba_\bs_\be_\bf_\bo_\bl_\bd_\bi_\bn_\bg\n",
       "\n",
       "_\bD_\be_\bs_\bc_\br_\bi_\bp_\bt_\bi_\bo_\bn:\n",
       "\n",
       "     Translate characters in character vectors, in particular from\n",
       "     upper to lower case or vice versa.\n",
       "\n",
       "_\bU_\bs_\ba_\bg_\be:\n",
       "\n",
       "     chartr(old, new, x)\n",
       "     tolower(x)\n",
       "     toupper(x)\n",
       "     casefold(x, upper = FALSE)\n",
       "     \n",
       "_\bA_\br_\bg_\bu_\bm_\be_\bn_\bt_\bs:\n",
       "\n",
       "       x: a character vector, or an object that can be coerced to\n",
       "          character by ‘as.character’.\n",
       "\n",
       "     old: a character string specifying the characters to be\n",
       "          translated.  If a character vector of length 2 or more is\n",
       "          supplied, the first element is used with a warning.\n",
       "\n",
       "     new: a character string specifying the translations. If a\n",
       "          character vector of length 2 or more is supplied, the first\n",
       "          element is used with a warning.\n",
       "\n",
       "   upper: logical: translate to upper or lower case?.\n",
       "\n",
       "_\bD_\be_\bt_\ba_\bi_\bl_\bs:\n",
       "\n",
       "     ‘chartr’ translates each character in ‘x’ that is specified in\n",
       "     ‘old’ to the corresponding character specified in ‘new’.  Ranges\n",
       "     are supported in the specifications, but character classes and\n",
       "     repeated characters are not.  If ‘old’ contains more characters\n",
       "     than new, an error is signaled; if it contains fewer characters,\n",
       "     the extra characters at the end of ‘new’ are ignored.\n",
       "\n",
       "     ‘tolower’ and ‘toupper’ convert upper-case characters in a\n",
       "     character vector to lower-case, or vice versa.  Non-alphabetic\n",
       "     characters are left unchanged.\n",
       "\n",
       "     ‘casefold’ is a wrapper for ‘tolower’ and ‘toupper’ provided for\n",
       "     compatibility with S-PLUS.\n",
       "\n",
       "_\bV_\ba_\bl_\bu_\be:\n",
       "\n",
       "     A character vector of the same length and with the same attributes\n",
       "     as ‘x’ (after possible coercion).\n",
       "\n",
       "     Elements of the result will be have the encoding declared as that\n",
       "     of the current locale (see ‘Encoding’) if the corresponding input\n",
       "     had a declared encoding and the current locale is either Latin-1\n",
       "     or UTF-8.  The result will be in the current locale's encoding\n",
       "     unless the corresponding input was in UTF-8, when it will be in\n",
       "     UTF-8 when the system has Unicode wide characters.\n",
       "\n",
       "_\bS_\be_\be _\bA_\bl_\bs_\bo:\n",
       "\n",
       "     ‘sub’ and ‘gsub’ for other substitutions in strings.\n",
       "\n",
       "_\bE_\bx_\ba_\bm_\bp_\bl_\be_\bs:\n",
       "\n",
       "     x <- \"MiXeD cAsE 123\"\n",
       "     chartr(\"iXs\", \"why\", x)\n",
       "     chartr(\"a-cX\", \"D-Fw\", x)\n",
       "     tolower(x)\n",
       "     toupper(x)\n",
       "     \n",
       "     ## \"Mixed Case\" Capitalizing - toupper( every first letter of a word ) :\n",
       "     \n",
       "     .simpleCap <- function(x) {\n",
       "         s <- strsplit(x, \" \")[[1]]\n",
       "         paste(toupper(substring(s, 1, 1)), substring(s, 2),\n",
       "               sep = \"\", collapse = \" \")\n",
       "     }\n",
       "     .simpleCap(\"the quick red fox jumps over the lazy brown dog\")\n",
       "     ## ->  [1] \"The Quick Red Fox Jumps Over The Lazy Brown Dog\"\n",
       "     \n",
       "     ## and the better, more sophisticated version:\n",
       "     capwords <- function(s, strict = FALSE) {\n",
       "         cap <- function(s) paste(toupper(substring(s, 1, 1)),\n",
       "                       {s <- substring(s, 2); if(strict) tolower(s) else s},\n",
       "                                  sep = \"\", collapse = \" \" )\n",
       "         sapply(strsplit(s, split = \" \"), cap, USE.NAMES = !is.null(names(s)))\n",
       "     }\n",
       "     capwords(c(\"using AIC for model selection\"))\n",
       "     ## ->  [1] \"Using AIC For Model Selection\"\n",
       "     capwords(c(\"using AIC\", \"for MODEL selection\"), strict = TRUE)\n",
       "     ## ->  [1] \"Using Aic\"  \"For Model Selection\"\n",
       "     ##                ^^^        ^^^^^\n",
       "     ##               'bad'       'good'\n",
       "     \n",
       "     ## -- Very simple insecure crypto --\n",
       "     rot <- function(ch, k = 13) {\n",
       "        p0 <- function(...) paste(c(...), collapse = \"\")\n",
       "        A <- c(letters, LETTERS, \" '\")\n",
       "        I <- seq_len(k); chartr(p0(A), p0(c(A[-I], A[I])), ch)\n",
       "     }\n",
       "     \n",
       "     pw <- \"my secret pass phrase\"\n",
       "     (crypw <- rot(pw, 13)) #-> you can send this off\n",
       "     \n",
       "     ## now ``decrypt'' :\n",
       "     rot(crypw, 54 - 13) # -> the original:\n",
       "     stopifnot(identical(pw, rot(crypw, 54 - 13)))\n",
       "     "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "help(tolower)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}