Getting Started with Julia.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Julia logo](images/julia-logo.png)\n",
    "\n",
    "\n",
    "<div style=\"text-align: center\">\n",
    "\n",
    "# Getting Started with Julia\n",
    "\n",
    "## Iowa Code Camp\n",
    "\n",
    "### December 8, 2018\n",
    "\n",
    "#### David W. Body\n",
    "\n",
    "#### Twitter: @david_body\n",
    "\n",
    "# Looks like Python, feels like Lisp, runs like Fortran\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction and Background\n",
    "\n",
    "* Created by Jeff Bezanson, Alan Edelman, Stefan Karpinski, and Viral B. Shah in 2009\n",
    "* [Released publicly in 2012](https://julialang.org/blog/2012/02/why-we-created-julia)\n",
    "* [Version 1.0 released August 2018](https://julialang.org/blog/2018/08/one-point-zero)\n",
    "\n",
    "#### Main language features\n",
    "\n",
    "* Multiple dispatch (parametric polymorphism)\n",
    "* Dynamic type system (\"optional\" typing)\n",
    "* High performance (approaching C, Fortran, etc.)\n",
    "* Built-in package manager\n",
    "* Lisp-like macros and metaprogramming\n",
    "* Interoperability with Python, R, C, Fortran\n",
    "* Designed for parallel and distributed computing\n",
    "\n",
    "Today we're going to just hit a few highlights and just scratch the surface.\n",
    "\n",
    "Goal is give everyone an idea of what Julia is like so you can decide if you want to learn more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Riddler example: Python vs Julia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Riddler Express\n",
    "\n",
    "https://fivethirtyeight.com/features/so-you-want-to-tether-your-goat-now-what/\n",
    "\n",
    "> From Luke Robinson, a serenading stumper:\n",
    "\n",
    "> My daughter really likes to hear me sing “The Unbirthday Song” from “Alice in Wonderland” to her. She also likes to sing it to other people. Obviously, the odds of my being able to sing it to her on any random day are 364 in 365, because I cannot sing it on her birthday. The question is, though, how many random people would she expect to be able to sing it to on any given day before it became more likely than not that she would encounter someone whose birthday it is? In other words, what is the expected length of her singing streak?\n",
    "\n",
    "First let's look at a [**Python** simulation](http://localhost:8888/notebooks/Unbirthday%20Riddler%20-%20Python.ipynb) to calculate the approximate expected length of the singing streak.\n",
    "\n",
    "Then let's compare a **Julia** simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Formatting\n",
    "using Statistics\n",
    "\n",
    "function trial()\n",
    "    n = 0\n",
    "    singing = true\n",
    "    while (singing)\n",
    "        if (rand(1:365) == 1)\n",
    "            singing = false\n",
    "        else\n",
    "            n += 1\n",
    "        end\n",
    "    end\n",
    "    return n\n",
    "end\n",
    "\n",
    "function do_trials(n_trials)\n",
    "    trials = zeros(Int, n_trials)\n",
    "    for i in 1:n_trials\n",
    "        trials[i] = trial()\n",
    "    end\n",
    "    mean(trials)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@time begin\n",
    "    n_trials = Int(1e6)\n",
    "    result = do_trials(n_trials)\n",
    "    println(\"Expected number of days: $result\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------\n",
    "\n",
    "#### A better (exact) solution\n",
    "\n",
    "The [Geometric distrubution](https://en.wikipedia.org/wiki/Geometric_distribution) is the probability distribution of the number $Y$ of failures of Bernoulli trials before the first success. The probability mass function for the Geometric distribution is\n",
    "\n",
    "$${\\Pr(Y=k)=(1-p)^{k}p}$$\n",
    "\n",
    "for k = 0, 1, 2, 3, .... where $p$ is probability of success for each Bernoulli trial.\n",
    "\n",
    "The mean of the Geometric distribution is\n",
    "\n",
    "$$E(Y) = \\frac{1 - p}{p}$$\n",
    "\n",
    "In our case, $p$ is the probability that a random person we encounter has a birthday today, so\n",
    "\n",
    "$$p = \\frac{1}{365}$$\n",
    "\n",
    "and therefore\n",
    "\n",
    "$$E(Y) = \\frac{1 - \\frac{1}{365}}{\\frac{1}{365}}$$\n",
    "\n",
    "$$ = \\frac{365 - \\frac{365}{365}}{\\frac{365}{365}}$$\n",
    "\n",
    "$$ = 365 - 1$$\n",
    "\n",
    "$$ = 364$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Selected Julia language features\n",
    "\n",
    "There is a lot more than we can cover today.\n",
    "\n",
    "## Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unicode and LaTeX variable names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Korean\n",
    "안녕하세요 = \"Hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "α = 1.0\n",
    "β₁ = 2.0\n",
    "β₂ = 3.0\n",
    "\n",
    "α + β₁ * 5.0 + β₂ * 3.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "π"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Even emojis\n",
    "\n",
    "Please don't ever do this. 😉"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "😺 = \"Smiley cat\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(😺)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "😺 = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(😺)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "😀 = 0\n",
    "😞 = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "😺 + 😞 == 😀"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aside"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0.1 + 0.2 == 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0.1 + 0.2 ≈ 0.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Selected data structures\n",
    "\n",
    "1. Tuples\n",
    "2. Dictionaries\n",
    "3. Arrays\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_favorite_languages = (\"Julia\", \"Python\", \"R\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_favorite_languages[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are immutable, so it's an error to try this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_favorite_languages[3] = \"Ruby\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = Dict(1 => 4.2, 2 => 5.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "keys(d1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values(d1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d2 = Dict(1 => 4.2, :two => \"hello\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d2[\"whatever\"] = true\n",
    "d2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can be explict about types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d3 = Dict{Symbol, Int64}(:a => 1, :b => 2, :c => 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Being explicit about types helps prevent certain kinds of bugs and also generally improves performance.\n",
    "\n",
    "This will be an error because the types don't match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d3[\"whatever\"] = true"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fibonacci = [1, 1, 2, 3, 5, 8, 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixture = [1, 1, 2, 3, \"Ted\", \"Robyn\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "push!(fibonacci, 21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fibonacci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pop!(fibonacci)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fibonacci"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assigment is by reference, so be careful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "somenumbers = fibonacci\n",
    "somenumbers[3] = 999"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fibonacci"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To avoid this, use the ```copy``` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple dimensional arrays are also supported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand(4, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand(3, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control Flow\n",
    "\n",
    "* Loops\n",
    "* Array comprehensions\n",
    "\n",
    "## Loops\n",
    "\n",
    "### while loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 0\n",
    "while n < 5\n",
    "    n += 1\n",
    "    println(n)\n",
    "end\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in 1:5\n",
    "    println(n)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create an addition table using some syntactic sugar for a nested for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m, n = 5, 5\n",
    "A = fill(0, (m, n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in 1:m, j in 1:n\n",
    "    A[i, j] = i + j\n",
    "end\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array comprehensions\n",
    "\n",
    "Here is the same thing in more idiomatic Julia using an *array comprehension*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = [i + j for i in 1:m, j in 1:n]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "This section is from Jane Herriman's [Introduction to Julia Tutorials](https://github.com/xorJane/Introduction_to_Julia_tutorials)\n",
    "\n",
    "Topics:\n",
    "1. How to declare a function\n",
    "2. Duck-typing in Julia\n",
    "3. Mutating vs. non-mutating functions\n",
    "4. Some higher order functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to declare a function\n",
    "Julia gives us a few different ways to write a function. The first requires the `function` and `end` keywords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function sayhi(name)\n",
    "    println(\"Hi $name, it's great to see you!\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function f(x)\n",
    "    x^2\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can call either of these functions like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayhi(\"C-3PO\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we could have declared either of these functions in a single line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayhi2(name) = println(\"Hi $name, it's great to see you!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f2(x) = x^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayhi2(\"R2D2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f2(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we could have declared these as \"anonymous\" functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayhi3 = name -> println(\"Hi $name, it's great to see you!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f3 = x -> x^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayhi3(\"Chewbacca\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f3(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x -> x^3)(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Duck-typing in Julia\n",
    "*\"If it quacks like a duck, it's a duck.\"* <br><br>\n",
    "Julia functions will just work on whatever inputs make sense. <br><br>\n",
    "For example, `sayhi` works on the name of this minor tv character, written as an integer..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayhi(55595472)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And `f` will work on a matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = rand(3, 3)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`f` will also work on a string like \"hi\" because `*` is defined for string inputs as string concatenation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(\"hi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the other hand, `f` will not work on a vector. Unlike `A^2`, which is well-defined, the meaning of `v^2` for a vector, `v`, is not a well-defined algebraic operation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = rand(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Mutating vs. non-mutating functions\n",
    "\n",
    "By convention, functions followed by `!` alter their contents and functions lacking `!` do not.\n",
    "\n",
    "For example, let's look at the difference between `sort` and `sort!`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [3, 5, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sort(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sort(v)` returns a sorted array that contains the same elements as `v`, but `v` is left unchanged. <br><br>\n",
    "\n",
    "On the other hand, when we run `sort!(v)`, the contents of v are sorted within the array `v`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sort!(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some higher order functions\n",
    "\n",
    "### map\n",
    "\n",
    "`map` is a \"higher-order\" function in Julia that *takes a function* as one of its input arguments. \n",
    "`map` then applies that function to every element of the data structure you pass it. For example, executing\n",
    "\n",
    "```julia\n",
    "map(f, [1, 2, 3])\n",
    "```\n",
    "will give you an output array where the function `f` has been applied to all elements of `[1, 2, 3]`\n",
    "```julia\n",
    "[f(1), f(2), f(3)]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map(f, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we've squared all the elements of the vector `[1, 2, 3]`, rather than squaring the vector `[1, 2, 3]`.\n",
    "\n",
    "To do this, we could have passed to `map` an anonymous function rather than a named function, such as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x -> x^3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "via"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map(x -> x^3, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and now we've cubed all the elements of `[1, 2, 3]`!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### broadcast\n",
    "\n",
    "`broadcast` is another higher-order function like `map`. `broadcast` is a generalization of `map`, so it can do every thing `map` can do and more. The syntax for calling `broadcast` is the same as for calling `map`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "broadcast(f, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and again, we've applied `f` (squared) to all the elements of `[1, 2, 3]` - this time by \"broadcasting\" `f`!\n",
    "\n",
    "Some syntactic sugar for calling `broadcast` is to place a `.` between the name of the function you want to `broadcast` and its input arguments. For example,\n",
    "\n",
    "```julia\n",
    "broadcast(f, [1, 2, 3])\n",
    "```\n",
    "is the same as\n",
    "```julia\n",
    "f.([1, 2, 3])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice again how different this is from calling \n",
    "```julia\n",
    "f([1, 2, 3])\n",
    "```\n",
    "We can square every element of a vector, but we can't square a vector!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To drive home the point, let's look at the difference between\n",
    "\n",
    "```julia\n",
    "f(A)\n",
    "```\n",
    "and\n",
    "```julia\n",
    "f.(A)\n",
    "```\n",
    "for a matrix `A`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [i + 3*j for j in 0:2, i in 1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before we see that for a matrix, `A`,\n",
    "```\n",
    "f(A) = A^2 = A * A\n",
    "``` \n",
    "\n",
    "On the other hand,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = f.(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "contains the squares of all the entries of `A`.\n",
    "\n",
    "This dot syntax for broadcasting allows us to write relatively complex compound elementwise expressions in a way that looks natural/closer to mathematical notation. For example, we can write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A .+ 2 .* f.(A) ./ A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "instead of"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "broadcast(x -> x + 2 * f(x) / x, A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and the two will perform exactly the same."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Type system and multiple dispatch\n",
    "\n",
    "This section is also from Jane Herriman's [Introduction to Julia Tutorials](https://github.com/xorJane/Introduction_to_Julia_tutorials)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we'll explore **multiple dispatch**, which is a key feature of Julia.\n",
    "\n",
    "Multiple dispatch makes software *generic* and *fast*!\n",
    "\n",
    "#### Starting with the familiar\n",
    "\n",
    "To understand multiple dispatch in Julia, let's start with what we've already seen.\n",
    "\n",
    "We can declare functions in Julia without giving Julia any information about the types of the input arguments that function will receive:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(x) = x^2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and then Julia will determine on its own which input argument types make sense and which do not:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Specifying the types of our input arguments\n",
    "\n",
    "However, we also have the *option* to tell Julia explicitly what types our input arguments are allowed to have.\n",
    "\n",
    "For example, let's write a function `foo` that only takes strings as inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo(x::String, y::String) = println(\"My inputs x and y are both strings!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see here that in order to restrict the type of `x` and `y` to `String`s, we just follow the input argument name by a double colon and the keyword `String`.\n",
    "\n",
    "Now we'll see that `foo` works on `String`s and doesn't work on other input argument types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo(\"hello\", \"hi!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get `foo` to work on integer (`Int`) inputs, let's tack `::Int` onto our input arguments when we declare `foo`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo(x::Int, y::Int) = println(\"My inputs x and y are both integers!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `foo` works on integers! But look, `foo` also still works when `x` and `y` are strings!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo(\"hello\", \"hi!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is starting to get to the heart of multiple dispatch. When we declared\n",
    "\n",
    "```julia\n",
    "foo(x::Int, y::Int) = println(\"My inputs x and y are both integers!\")\n",
    "```\n",
    "we didn't overwrite or replace\n",
    "```julia\n",
    "foo(y::String, y::String)```\n",
    "\n",
    "Instead, we just added an additional ***method*** to the ***generic function*** called `foo`.\n",
    "\n",
    "A ***generic function*** is the abstract concept associated with a particular operation.\n",
    "\n",
    "For example, the generic function `+` represents the concept of addition.\n",
    "\n",
    "A ***method*** is a specific implementation of a generic function for *particular argument types*.\n",
    "\n",
    "For example, `+` has methods that accept floating point numbers, integers, matrices, etc.\n",
    "\n",
    "We can use the `methods` to see how many methods there are for `foo`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "methods(foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aside: how many methods do you think there are for addition?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "methods(+)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, we now can call `foo` on integers or strings. When you call `foo` on a particular set of arguments, Julia will infer the types of the inputs and dispatch the appropriate method. *This* is multiple dispatch.\n",
    "\n",
    "Multiple dispatch makes our code generic and fast. Our code can be generic and flexible because we can write code in terms of abstract operations such as addition and multiplication, rather than in terms of specific implementations. At the same time, our code runs quickly because Julia is able to call efficient methods for the relevant types.\n",
    "\n",
    "To see which method is being dispatched when we call a generic function, we can use the @which macro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@which foo(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what happens when we use `@which` with the addition operator!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@which 3.0 + 3.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can continue to add other methods to our generic function `foo`. Let's add one that takes the ***abstract type*** `Number`, which includes subtypes such as `Int`, `Float64`, and other objects you would think of as numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo(x::Number, y::Number) = println(\"My inputs x and y are both numbers!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This method for `foo` will work on, for example, floating point numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add a fallback, duck-typed method for `foo` that takes inputs of any type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo(x, y) = println(\"I accept inputs of any type!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given the methods we've already written for `foo` so far, this method will be called whenever we pass non-numbers to `foo`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = rand(3)\n",
    "foo(v, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metaprogramming\n",
    "\n",
    "From Wikipedia:\n",
    "\n",
    "> In computer programming, **homoiconicity** (from the Greek words homo- meaning \"the same\" and icon meaning \"representation\") is a property of some programming languages. A language is **homoiconic** if a program written in it can be manipulated as data using the language, and thus the program's internal representation can be inferred just by reading the program itself. For example, a Lisp program is written as a regular Lisp list, and can be manipulated by other Lisp code.[1] In homoiconic languages, all code can be accessed and transformed as data, using the same representation. This property is often summarized by saying that the language treats \"code as data\".\n",
    "\n",
    "Julia is homoiconic. In Julia, program code can be represented by a Julia data structure called an expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Meta.parse(\"2 + 3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_plus_three = :(2 + 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is known as *quoting* and `:` is the `quote` operator.\n",
    "\n",
    "Code with more than one line can be quoted like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quote\n",
    "    a = 42\n",
    "    b = a^2\n",
    "    a - b\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(two_plus_three)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dump(two_plus_three)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`head` indicates that this expression is a function call. `args` is an array containing the function and its arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_plus_three.args[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make a copy of the expression and modify the first `arg`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_minus_three = copy(two_plus_three)\n",
    "two_minus_three.args[1] = :-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_plus_three"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can look at and evaluate the modified expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_minus_three"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(two_minus_three)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Macro example\n",
    "\n",
    "Using the above and just a little more metaprogramming machinery, we can create powerful *macros*.\n",
    "\n",
    "Here is an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "macro timeit(ex)\n",
    "    quote\n",
    "        local t0 = time()\n",
    "        local val = $(esc(ex))\n",
    "        local t1 = time()\n",
    "        println(\"elapsed time: \", t1-t0, \" seconds\")\n",
    "        val\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@timeit factorial(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Julia comes with a built-in `@time` macro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@time factorial(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parallel computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another Riddler\n",
    "\n",
    "https://fivethirtyeight.com/features/so-you-want-to-tether-your-goat-now-what/\n",
    "\n",
    "## Riddler Classic\n",
    "\n",
    "From Moritz Hesse, some grazing geometry:\n",
    "\n",
    "> A farmer owns a circular field with radius R. If he ties up his goat to the fence that runs along the edge of the field, how long does the goat’s tether need to be so that the goat can graze on exactly half of the field, by area?\n",
    "\n",
    "> (The great thing about this puzzle, Moritz notes, is that if you get sick of math, you can find the answer through trial and error with your own circular field and your favorite goat, horse, cow, kangaroo, sheep, unicorn, centaur or sphinx.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function randPoint()\n",
    "    # randr = rand()\n",
    "    randr = sqrt(rand())\n",
    "    theta = rand() * 2 * π\n",
    "    randr * cos(theta), randr * sin(theta)\n",
    "end\n",
    "\n",
    "function grazeable(x, y, r)\n",
    "    (x - 1)^2 + y^2 <= r^2\n",
    "end\n",
    "\n",
    "function trial(n, r)\n",
    "    grazeables = 0\n",
    "    for i = 1:n\n",
    "        x, y = randPoint()\n",
    "        grazeables += grazeable(x, y, r) ? 1 : 0\n",
    "    end\n",
    "    grazeables / n\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the following plot will show, there is subtle but fatal flaw with this implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Plots\n",
    "pyplot()\n",
    "\n",
    "points = [randPoint() for p in 1:1e3]\n",
    "x = [p[1] for p in points]\n",
    "y = [p[2] for p in points]\n",
    "\n",
    "scatter(x, y, aspect_ratio = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As explained [here](https://programming.guide/random-point-within-circle.html), to generate random points uniformly over a circle, the radius should be the **square root** of a uniformly randomly distributed number.\n",
    "\n",
    "Let's fix that and try again, this time coloring points that grazeable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tether_length = 1.5\n",
    "\n",
    "points = [randPoint() for p in 1:1e3]\n",
    "g = [grazeable(p[1], p[2], tether_length) ? \"green\" : \"white\" for p in points];\n",
    "x = [p[1] for p in points]\n",
    "y = [p[2] for p in points];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatter(x, y, c = g, aspect_ratio = 1, title = \"Tether length $tether_length\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We \"solve\" for tether length by trying different values until we get a result that is a close to 0.5 as we can get."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tether_length = 1.0\n",
    "\n",
    "n_trials = 1e5\n",
    "println(\"Performing \", format(n_trials, commas = true), \" trials...\")\n",
    "\n",
    "println(trial(n_trials, tether_length))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution is ~ 1.159\n",
    "tether_length = 1.159\n",
    "\n",
    "n_trials = 1e9\n",
    "println(\"Performing \", format(n_trials, commas = true), \" trials...\")\n",
    "\n",
    "@time trial(n_trials, tether_length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To speed this up, we can parallelize the computation using functionality in Julia's standard library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Distributed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nprocs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "addprocs(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@everywhere function randPoint()\n",
    "    randr = sqrt(rand())\n",
    "    theta = rand() * 2 * π\n",
    "    randr * cos(theta), randr * sin(theta)\n",
    "end\n",
    "\n",
    "@everywhere function grazeable(x, y, r)\n",
    "    (x - 1)^2 + y^2 <= r^2\n",
    "end\n",
    "\n",
    "@everywhere function trial(n, r)\n",
    "    grazeables = @distributed (+) for i = 1:n\n",
    "        x, y = randPoint()\n",
    "        grazeable(x, y, r) ? 1 : 0\n",
    "    end\n",
    "    grazeables / n\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_trials = 1e9\n",
    "println(\"Performing \", format(n_trials, commas = true), \" trials using \", nprocs(), \" processes...\")\n",
    "\n",
    "# Solution is ~ 1.159\n",
    "@time println(trial(n_trials, 1.159))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's plot a diagram of our solution.\n",
    "\n",
    "This time we'll call PyPlot directly using Julia's PyCall package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PyPlot\n",
    "using PyCall\n",
    "@pyimport matplotlib.patches as patch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tether_length = 1.159"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fix, ax = subplots()\n",
    "\n",
    "field_circle = patch.Circle((0, 0), 1, facecolor = \"none\", edgecolor = (0, 0.8, 0))\n",
    "goat_circle = patch.Circle((1, 0), tether_length, facecolor = \"none\", edgecolor = (0, 0, 0.8))\n",
    "\n",
    "ax[:add_patch](field_circle)\n",
    "ax[:add_patch](goat_circle)\n",
    "\n",
    "ax[:plot]((1, 1 - tether_length), (0, 0), color = \"black\", alpha = 0.7, linestyle = \":\")\n",
    "\n",
    "ax[:set_aspect](1.0)\n",
    "ax[:set_xlim](-1.5, 2.5)\n",
    "ax[:set_ylim](-1.5, 1.5)\n",
    "\n",
    "ax[:set_title](\"Tether (dotted line) length is $tether_length times the radius of the field\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.1.1",
   "language": "julia",
   "name": "julia-1.1"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.1.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}