tutorial/00.Julia_is_fast.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# Julia is fast\n",
    "(Originally from https://github.com/JuliaAcademy/JuliaTutorials under introductory-tutorials/intro-to-julia)\n",
    "\n",
    "Very often, benchmarks are used to compare languages.  These benchmarks can lead to long discussions, first as to exactly what is being benchmarked and secondly what explains the differences.  These simple questions can sometimes get more complicated than you at first might imagine.\n",
    "\n",
    "The purpose of this notebook is for you to see a simple benchmark for yourself.  One can read the notebook and see what happened on the author's Macbook Pro with a 4-core Intel Core I7, or run the notebook yourself.\n",
    "\n",
    "(This material began life as a wonderful lecture by Steven Johnson at MIT: https://github.com/stevengj/18S096/blob/master/lectures/lecture1/Boxes-and-registers.ipynb.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Outline of this notebook\n",
    "\n",
    "- Define the sum function\n",
    "- Implementations & benchmarking of sum in...\n",
    "    - C (hand-written)\n",
    "    - python (built-in)\n",
    "    - python (numpy)\n",
    "    - python (hand-written)\n",
    "    - Julia (built-in)\n",
    "    - Julia (hand-written)\n",
    "    - Julia (hand-written with SIMD)\n",
    "- Summary of benchmarks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `sum`: An easy enough function to understand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Consider the  **sum** function `sum(a)`, which computes\n",
    "$$\n",
    "\\mathrm{sum}(a) = \\sum_{i=1}^n a_i,\n",
    "$$\n",
    "where $n$ is the length of `a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×10000000 LinearAlgebra.Adjoint{Float64,Array{Float64,1}}:\n",
       " 0.552539  0.258208  0.915003  0.311946  0.566518  0.797539  …  0.371666  0.874289  0.165394  0.836368  0.987329  0.497902"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = rand(10^7) # 1D vector of random numbers, uniform on [0,1)\n",
    "a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0001838760484345e6"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The expected result is 5 * 10^6, since the mean of each entry is 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Benchmarking a few ways in a few languages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n",
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n",
      "\u001b[?25l\u001b[2K\u001b[?25h\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m `/scratch/users/dyuret/.julia/environments/v1.3/Project.toml`\n",
      " \u001b[90m [438e738f]\u001b[39m\u001b[92m + PyCall v1.91.2\u001b[39m\n",
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m `/scratch/users/dyuret/.julia/environments/v1.3/Manifest.toml`\n",
      " \u001b[90m [438e738f]\u001b[39m\u001b[92m + PyCall v1.91.2\u001b[39m\n",
      "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m `/scratch/users/dyuret/.julia/environments/v1.3/Project.toml`\n",
      " \u001b[90m [8f4d0f93]\u001b[39m\u001b[92m + Conda v1.3.0\u001b[39m\n",
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m `/scratch/users/dyuret/.julia/environments/v1.3/Manifest.toml`\n",
      "\u001b[90m [no changes]\u001b[39m\n"
     ]
    }
   ],
   "source": [
    "using Pkg\n",
    "pkg\"add BenchmarkTools Plots PyCall Conda\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.007332 seconds (5 allocations: 176 bytes)\n",
      "  0.006986 seconds (5 allocations: 176 bytes)\n",
      "  0.006951 seconds (5 allocations: 176 bytes)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5.0001838760484345e6"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@time sum(a)\n",
    "\n",
    "@time sum(a)\n",
    "\n",
    "@time sum(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The `@time` macro can yield noisy results, so it's not our best choice for benchmarking!\n",
    "\n",
    "Luckily, Julia has a `BenchmarkTools.jl` package to make benchmarking easy and accurate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "┌ Info: Precompiling BenchmarkTools [6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf]\n",
      "└ @ Base loading.jl:1273\n"
     ]
    }
   ],
   "source": [
    "using BenchmarkTools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#  1. The C language\n",
    "\n",
    "C is often considered the gold standard: difficult on the human, nice for the machine. Getting within a factor of 2 of C is often satisfying. Nonetheless, even within C, there are many kinds of optimizations possible that a naive C writer may or may not get the advantage of.\n",
    "\n",
    "The current author does not speak C, so he does not read the cell below, but is happy to know that you can put C code in a Julia session, compile it, and run it. Note that the `\"\"\"` wrap a multi-line string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c_sum (generic function with 1 method)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Libdl\n",
    "\n",
    "C_code = \"\"\"\n",
    "#include <stddef.h>\n",
    "double c_sum(size_t n, double *X) {\n",
    "    double s = 0.0;\n",
    "    for (size_t i = 0; i < n; ++i) {\n",
    "        s += X[i];\n",
    "    }\n",
    "    return s;\n",
    "}\n",
    "\"\"\"\n",
    "\n",
    "const Clib = tempname()   # make a temporary file\n",
    "# compile to a shared library by piping C_code to gcc\n",
    "# (works only if you have gcc installed):\n",
    "open(`gcc -std=c99 -fPIC -O3 -msse3 -xc -shared -o $(Clib * \".\" * Libdl.dlext) -`, \"w\") do f\n",
    "    print(f, C_code) \n",
    "end\n",
    "# define a Julia function that calls the C function:\n",
    "c_sum(X::Array{Float64}) = ccall((\"c_sum\", Clib), Float64, (Csize_t, Ptr{Float64}), length(X), X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.000183876048526e6"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_sum(a) ≈ sum(a) # type \\approx and then <TAB> to get the ≈ symbolb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.12696123123169e-8"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_sum(a) - sum(a)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "isapprox (generic function with 8 methods)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "≈  # alias for the `isapprox` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mx\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "isapprox(x, y; rtol::Real=atol>0 ? 0 : √eps, atol::Real=0, nans::Bool=false, norm::Function)\n",
       "\\end{verbatim}\n",
       "Inexact equality comparison: \\texttt{true} if \\texttt{norm(x-y) <= max(atol, rtol*max(norm(x), norm(y)))}. The default \\texttt{atol} is zero and the default \\texttt{rtol} depends on the types of \\texttt{x} and \\texttt{y}. The keyword argument \\texttt{nans} determines whether or not NaN values are considered equal (defaults to false).\n",
       "\n",
       "For real or complex floating-point values, if an \\texttt{atol > 0} is not specified, \\texttt{rtol} defaults to the square root of \\href{@ref}{\\texttt{eps}} of the type of \\texttt{x} or \\texttt{y}, whichever is bigger (least precise). This corresponds to requiring equality of about half of the significand digits. Otherwise, e.g. for integer arguments or if an \\texttt{atol > 0} is supplied, \\texttt{rtol} defaults to zero.\n",
       "\n",
       "\\texttt{x} and \\texttt{y} may also be arrays of numbers, in which case \\texttt{norm} defaults to the usual \\texttt{norm} function in LinearAlgebra, but may be changed by passing a \\texttt{norm::Function} keyword argument. (For numbers, \\texttt{norm} is the same thing as \\texttt{abs}.) When \\texttt{x} and \\texttt{y} are arrays, if \\texttt{norm(x-y)} is not finite (i.e. \\texttt{±Inf} or \\texttt{NaN}), the comparison falls back to checking whether all elements of \\texttt{x} and \\texttt{y} are approximately equal component-wise.\n",
       "\n",
       "The binary operator \\texttt{≈} is equivalent to \\texttt{isapprox} with the default arguments, and \\texttt{x ≉ y} is equivalent to \\texttt{!isapprox(x,y)}.\n",
       "\n",
       "Note that \\texttt{x ≈ 0} (i.e., comparing to zero with the default tolerances) is equivalent to \\texttt{x == 0} since the default \\texttt{atol} is \\texttt{0}.  In such cases, you should either supply an appropriate \\texttt{atol} (or use \\texttt{norm(x) ≤ atol}) or rearrange your code (e.g. use \\texttt{x ≈ y} rather than \\texttt{x - y ≈ 0}).   It is not possible to pick a nonzero \\texttt{atol} automatically because it depends on the overall scaling (the \"units\") of your problem: for example, in \\texttt{x - y ≈ 0}, \\texttt{atol=1e-9} is an absurdly small tolerance if \\texttt{x} is the \\href{https://en.wikipedia.org/wiki/Earth_radius}{radius of the Earth} in meters, but an absurdly large tolerance if \\texttt{x} is the \\href{https://en.wikipedia.org/wiki/Bohr_radius}{radius of a Hydrogen atom} in meters.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> 0.1 ≈ (0.1 - 1e-10)\n",
       "true\n",
       "\n",
       "julia> isapprox(10, 11; atol = 2)\n",
       "true\n",
       "\n",
       "julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0])\n",
       "true\n",
       "\n",
       "julia> 1e-10 ≈ 0\n",
       "false\n",
       "\n",
       "julia> isapprox(1e-10, 0, atol=1e-8)\n",
       "true\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "```\n",
       "isapprox(x, y; rtol::Real=atol>0 ? 0 : √eps, atol::Real=0, nans::Bool=false, norm::Function)\n",
       "```\n",
       "\n",
       "Inexact equality comparison: `true` if `norm(x-y) <= max(atol, rtol*max(norm(x), norm(y)))`. The default `atol` is zero and the default `rtol` depends on the types of `x` and `y`. The keyword argument `nans` determines whether or not NaN values are considered equal (defaults to false).\n",
       "\n",
       "For real or complex floating-point values, if an `atol > 0` is not specified, `rtol` defaults to the square root of [`eps`](@ref) of the type of `x` or `y`, whichever is bigger (least precise). This corresponds to requiring equality of about half of the significand digits. Otherwise, e.g. for integer arguments or if an `atol > 0` is supplied, `rtol` defaults to zero.\n",
       "\n",
       "`x` and `y` may also be arrays of numbers, in which case `norm` defaults to the usual `norm` function in LinearAlgebra, but may be changed by passing a `norm::Function` keyword argument. (For numbers, `norm` is the same thing as `abs`.) When `x` and `y` are arrays, if `norm(x-y)` is not finite (i.e. `±Inf` or `NaN`), the comparison falls back to checking whether all elements of `x` and `y` are approximately equal component-wise.\n",
       "\n",
       "The binary operator `≈` is equivalent to `isapprox` with the default arguments, and `x ≉ y` is equivalent to `!isapprox(x,y)`.\n",
       "\n",
       "Note that `x ≈ 0` (i.e., comparing to zero with the default tolerances) is equivalent to `x == 0` since the default `atol` is `0`.  In such cases, you should either supply an appropriate `atol` (or use `norm(x) ≤ atol`) or rearrange your code (e.g. use `x ≈ y` rather than `x - y ≈ 0`).   It is not possible to pick a nonzero `atol` automatically because it depends on the overall scaling (the \"units\") of your problem: for example, in `x - y ≈ 0`, `atol=1e-9` is an absurdly small tolerance if `x` is the [radius of the Earth](https://en.wikipedia.org/wiki/Earth_radius) in meters, but an absurdly large tolerance if `x` is the [radius of a Hydrogen atom](https://en.wikipedia.org/wiki/Bohr_radius) in meters.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> 0.1 ≈ (0.1 - 1e-10)\n",
       "true\n",
       "\n",
       "julia> isapprox(10, 11; atol = 2)\n",
       "true\n",
       "\n",
       "julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0])\n",
       "true\n",
       "\n",
       "julia> 1e-10 ≈ 0\n",
       "false\n",
       "\n",
       "julia> isapprox(1e-10, 0, atol=1e-8)\n",
       "true\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  isapprox(x, y; rtol::Real=atol>0 ? 0 : √eps, atol::Real=0, nans::Bool=false, norm::Function)\u001b[39m\n",
       "\n",
       "  Inexact equality comparison: \u001b[36mtrue\u001b[39m if \u001b[36mnorm(x-y) <= max(atol, rtol*max(norm(x), norm(y)))\u001b[39m. The default \u001b[36matol\u001b[39m is zero and the\n",
       "  default \u001b[36mrtol\u001b[39m depends on the types of \u001b[36mx\u001b[39m and \u001b[36my\u001b[39m. The keyword argument \u001b[36mnans\u001b[39m determines whether or not NaN values are considered\n",
       "  equal (defaults to false).\n",
       "\n",
       "  For real or complex floating-point values, if an \u001b[36matol > 0\u001b[39m is not specified, \u001b[36mrtol\u001b[39m defaults to the square root of \u001b[36meps\u001b[39m of the type\n",
       "  of \u001b[36mx\u001b[39m or \u001b[36my\u001b[39m, whichever is bigger (least precise). This corresponds to requiring equality of about half of the significand digits.\n",
       "  Otherwise, e.g. for integer arguments or if an \u001b[36matol > 0\u001b[39m is supplied, \u001b[36mrtol\u001b[39m defaults to zero.\n",
       "\n",
       "  \u001b[36mx\u001b[39m and \u001b[36my\u001b[39m may also be arrays of numbers, in which case \u001b[36mnorm\u001b[39m defaults to the usual \u001b[36mnorm\u001b[39m function in LinearAlgebra, but may be\n",
       "  changed by passing a \u001b[36mnorm::Function\u001b[39m keyword argument. (For numbers, \u001b[36mnorm\u001b[39m is the same thing as \u001b[36mabs\u001b[39m.) When \u001b[36mx\u001b[39m and \u001b[36my\u001b[39m are arrays, if\n",
       "  \u001b[36mnorm(x-y)\u001b[39m is not finite (i.e. \u001b[36m±Inf\u001b[39m or \u001b[36mNaN\u001b[39m), the comparison falls back to checking whether all elements of \u001b[36mx\u001b[39m and \u001b[36my\u001b[39m are\n",
       "  approximately equal component-wise.\n",
       "\n",
       "  The binary operator \u001b[36m≈\u001b[39m is equivalent to \u001b[36misapprox\u001b[39m with the default arguments, and \u001b[36mx ≉ y\u001b[39m is equivalent to \u001b[36m!isapprox(x,y)\u001b[39m.\n",
       "\n",
       "  Note that \u001b[36mx ≈ 0\u001b[39m (i.e., comparing to zero with the default tolerances) is equivalent to \u001b[36mx == 0\u001b[39m since the default \u001b[36matol\u001b[39m is \u001b[36m0\u001b[39m. In\n",
       "  such cases, you should either supply an appropriate \u001b[36matol\u001b[39m (or use \u001b[36mnorm(x) ≤ atol\u001b[39m) or rearrange your code (e.g. use \u001b[36mx ≈ y\u001b[39m rather\n",
       "  than \u001b[36mx - y ≈ 0\u001b[39m). It is not possible to pick a nonzero \u001b[36matol\u001b[39m automatically because it depends on the overall scaling (the \"units\")\n",
       "  of your problem: for example, in \u001b[36mx - y ≈ 0\u001b[39m, \u001b[36matol=1e-9\u001b[39m is an absurdly small tolerance if \u001b[36mx\u001b[39m is the radius of the Earth\n",
       "  (https://en.wikipedia.org/wiki/Earth_radius) in meters, but an absurdly large tolerance if \u001b[36mx\u001b[39m is the radius of a Hydrogen atom\n",
       "  (https://en.wikipedia.org/wiki/Bohr_radius) in meters.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> 0.1 ≈ (0.1 - 1e-10)\u001b[39m\n",
       "\u001b[36m  true\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> isapprox(10, 11; atol = 2)\u001b[39m\n",
       "\u001b[36m  true\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0])\u001b[39m\n",
       "\u001b[36m  true\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> 1e-10 ≈ 0\u001b[39m\n",
       "\u001b[36m  false\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> isapprox(1e-10, 0, atol=1e-8)\u001b[39m\n",
       "\u001b[36m  true\u001b[39m"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?isapprox"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "We can now benchmark the C code directly from Julia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     12.789 ms (0.00% GC)\n",
       "  median time:      13.022 ms (0.00% GC)\n",
       "  mean time:        13.251 ms (0.00% GC)\n",
       "  maximum time:     14.242 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          378\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_bench = @benchmark c_sum($a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C: Fastest time was 12.788873 msec\n"
     ]
    }
   ],
   "source": [
    "println(\"C: Fastest time was $(minimum(c_bench.times) / 1e6) msec\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Any,Any} with 1 entry:\n",
       "  \"C\" => 12.7889"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = Dict()  # a \"dictionary\", i.e. an associative array\n",
    "d[\"C\"] = minimum(c_bench.times) / 1e6  # in milliseconds\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "┌ Info: Precompiling Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80]\n",
      "└ @ Base loading.jl:1273\n"
     ]
    }
   ],
   "source": [
    "using Plots, Statistics\n",
    "default(fmt = :png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = c_bench.times / 1e6 # times in milliseconds\n",
    "m, σ = minimum(t), std(t)\n",
    "\n",
    "histogram(t, bins=500,\n",
    "    xlim=(m - 0.01, m + σ),\n",
    "    xlabel=\"milliseconds\", ylabel=\"count\", label=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 2. Python's built in `sum` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `PyCall` package provides a Julia interface to Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "┌ Info: Precompiling PyCall [438e738f-606a-5dbb-bf0a-cddfbfd45ab0]\n",
      "└ @ Base loading.jl:1273\n"
     ]
    }
   ],
   "source": [
    "using PyCall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PyObject <built-in function sum>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call a low-level PyCall function to get a Python list, because\n",
    "# by default PyCall will convert to a NumPy array instead (we benchmark NumPy below):\n",
    "\n",
    "apy_list = PyCall.array2py(a)\n",
    "\n",
    "# get the Python built-in \"sum\" function:\n",
    "pysum = pybuiltin(\"sum\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.000183876048526e6"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pysum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pysum(a) ≈ sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  48 bytes\n",
       "  allocs estimate:  3\n",
       "  --------------\n",
       "  minimum time:     52.765 ms (0.00% GC)\n",
       "  median time:      53.412 ms (0.00% GC)\n",
       "  mean time:        53.492 ms (0.00% GC)\n",
       "  maximum time:     54.651 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          94\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "py_list_bench = @benchmark $pysum($apy_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Any,Any} with 2 entries:\n",
       "  \"C\"               => 12.7889\n",
       "  \"Python built-in\" => 52.7653"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"Python built-in\"] = minimum(py_list_bench.times) / 1e6\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 3. Python: `numpy` \n",
    "\n",
    "## Takes advantage of hardware \"SIMD\", but only works when it works.\n",
    "\n",
    "`numpy` is an optimized C library, callable from Python.\n",
    "It may be installed within Julia as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "using Conda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PyObject array([0.55253876, 0.25820791, 0.91500348, ..., 0.83636827, 0.98732927,\n",
       "       0.49790172])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_sum = pyimport(\"numpy\").\"sum\"\n",
    "apy_numpy = PyObject(a) # converts to a numpy array by default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.000183876048442e6"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_sum(apy_list) # python thing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  48 bytes\n",
       "  allocs estimate:  3\n",
       "  --------------\n",
       "  minimum time:     8.965 ms (0.00% GC)\n",
       "  median time:      9.206 ms (0.00% GC)\n",
       "  mean time:        9.238 ms (0.00% GC)\n",
       "  maximum time:     9.728 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          541\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "py_numpy_bench = @benchmark $numpy_sum($apy_numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_sum(apy_list) ≈ sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Any,Any} with 3 entries:\n",
       "  \"C\"               => 12.7889\n",
       "  \"Python numpy\"    => 8.96538\n",
       "  \"Python built-in\" => 52.7653"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"Python numpy\"] = minimum(py_numpy_bench.times) / 1e6\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 4. Python, hand-written "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PyObject <function py_sum at 0x7fae56d02bf8>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "py\"\"\"\n",
    "def py_sum(A):\n",
    "    s = 0.0\n",
    "    for a in A:\n",
    "        s += a\n",
    "    return s\n",
    "\"\"\"\n",
    "\n",
    "sum_py = py\"py_sum\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.000183876048526e6"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_py(apy_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  48 bytes\n",
       "  allocs estimate:  3\n",
       "  --------------\n",
       "  minimum time:     193.518 ms (0.00% GC)\n",
       "  median time:      194.938 ms (0.00% GC)\n",
       "  mean time:        195.798 ms (0.00% GC)\n",
       "  maximum time:     211.531 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          26\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "py_hand = @benchmark $sum_py($apy_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_py(apy_list) ≈ sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Any,Any} with 4 entries:\n",
       "  \"C\"                   => 12.7889\n",
       "  \"Python numpy\"        => 8.96538\n",
       "  \"Python hand-written\" => 193.518\n",
       "  \"Python built-in\"     => 52.7653"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"Python hand-written\"] = minimum(py_hand.times) / 1e6\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 5. Julia (built-in) \n",
    "\n",
    "## Written directly in Julia, not in C!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "sum(a::<b>AbstractArray</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/2d5741174ce3e6a394010d2e470e4269ca54607f/base/reducedim.jl#L652\" target=\"_blank\">reducedim.jl:652</a>"
      ],
      "text/plain": [
       "sum(a::AbstractArray) in Base at reducedim.jl:652"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@which sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0001838760484345e6"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     6.178 ms (0.00% GC)\n",
       "  median time:      6.391 ms (0.00% GC)\n",
       "  mean time:        6.434 ms (0.00% GC)\n",
       "  maximum time:     6.918 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          777\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j_bench = @benchmark sum($a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Any,Any} with 5 entries:\n",
       "  \"C\"                   => 12.7889\n",
       "  \"Python numpy\"        => 8.96538\n",
       "  \"Python hand-written\" => 193.518\n",
       "  \"Python built-in\"     => 52.7653\n",
       "  \"Julia built-in\"      => 6.17809"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"Julia built-in\"] = minimum(j_bench.times) / 1e6\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 6. Julia (hand-written) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mysum (generic function with 1 method)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function mysum(A)   \n",
    "    s = 0.0 # s = zero(eltype(a))\n",
    "    for a in A\n",
    "        s += a\n",
    "    end\n",
    "    s\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.000183876048526e6"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     13.009 ms (0.00% GC)\n",
       "  median time:      14.286 ms (0.00% GC)\n",
       "  mean time:        14.179 ms (0.00% GC)\n",
       "  maximum time:     15.345 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          353\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j_bench_hand = @benchmark mysum($a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Any,Any} with 6 entries:\n",
       "  \"C\"                   => 12.7889\n",
       "  \"Python numpy\"        => 8.96538\n",
       "  \"Julia hand-written\"  => 13.0087\n",
       "  \"Python hand-written\" => 193.518\n",
       "  \"Python built-in\"     => 52.7653\n",
       "  \"Julia built-in\"      => 6.17809"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"Julia hand-written\"] = minimum(j_bench_hand.times) / 1e6\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 7. Julia (hand-written w. simd) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mysum_simd (generic function with 1 method)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function mysum_simd(A)   \n",
    "    s = 0.0 # s = zero(eltype(A))\n",
    "    @simd for a in A\n",
    "        s += a\n",
    "    end\n",
    "    s\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.000183876048463e6"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum_simd(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     5.851 ms (0.00% GC)\n",
       "  median time:      6.080 ms (0.00% GC)\n",
       "  mean time:        6.080 ms (0.00% GC)\n",
       "  maximum time:     6.440 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          822\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j_bench_hand_simd = @benchmark mysum_simd($a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Any,Any} with 7 entries:\n",
       "  \"Julia hand-written simd\" => 5.85122\n",
       "  \"C\"                       => 12.7889\n",
       "  \"Python numpy\"            => 8.96538\n",
       "  \"Julia hand-written\"      => 13.0087\n",
       "  \"Python hand-written\"     => 193.518\n",
       "  \"Python built-in\"         => 52.7653\n",
       "  \"Julia built-in\"          => 6.17809"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"Julia hand-written simd\"] = minimum(j_bench_hand_simd.times) / 1e6\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Julia hand-written simd.....5.9\n",
      "Julia built-in..............6.2\n",
      "Python numpy................9.0\n",
      "C..........................12.8\n",
      "Julia hand-written.........13.0\n",
      "Python built-in............52.8\n",
      "Python hand-written.......193.5\n"
     ]
    }
   ],
   "source": [
    "for (key, value) in sort(collect(d), by=last)\n",
    "    println(rpad(key, 25, \".\"), lpad(round(value, digits=1), 6, \".\"))\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "accelerator": "GPU",
  "anaconda-cloud": {},
  "colab": {
   "collapsed_sections": [],
   "name": "julia.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Julia 1.5.0",
   "language": "julia",
   "name": "julia-1.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.5.0"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "212px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": "2",
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}