MyThinkJulia-Ch20-BaseStandardLibrary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch 20: Base and Standard Library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`import Module` imports the module, and `Module.fn(x)` calls the function `f`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measuring Performance\n",
    "\n",
    "We have seen that some algorithms perform better than others. `fibonnaci` with memos is a lot faster than `fib` without memoization. The @time macro allows to quantify the difference.\n",
    "\n",
    "@time prints the time the function took to execute, the number of allocations and the allocated memory before returning the result. The memoized version is effectively a lot faster but needs more memory.\n",
    "\n",
    "TIP:  A function in Julia is compiled the first time it is executed. So to compare two algorithms, they have to be implemented as functions to get compiled and the first time they are called has to be excluded from the performance measure, otherwise the compilation time is measured as well. The package BenchmarkTools (https://github.com/JuliaCI/BenchmarkTools.jl) provides the macro @btime that does benchmarking the right way. So just use it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fib (generic function with 1 method)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "known = Dict(0=>0, 1=>1)\n",
    "\n",
    "function fibonacci(n)\n",
    "    if n ∈ keys(known)\n",
    "        return known[n]\n",
    "    end\n",
    "    res = fibonacci(n-1) + fibonacci(n-2)\n",
    "    known[n] = res\n",
    "    res\n",
    "end\n",
    "\n",
    "\n",
    "\n",
    "function fib(n)\n",
    "    if n == 0\n",
    "        return 0\n",
    "    elseif n == 1\n",
    "        return 1\n",
    "    else\n",
    "        return fib(n-1) + fib(n-2)\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m registry at `C:\\Users\\ST\\.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 `C:\\Users\\ST\\.julia\\environments\\v1.2\\Project.toml`\n",
      "\u001b[90m [no changes]\u001b[39m\n",
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m `C:\\Users\\ST\\.julia\\environments\\v1.2\\Manifest.toml`\n",
      "\u001b[90m [no changes]\u001b[39m\n"
     ]
    }
   ],
   "source": [
    "using Pkg\n",
    "Pkg.add(\"BenchmarkTools\")\n",
    "using BenchmarkTools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  113.597 ns (2 allocations: 32 bytes)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "75025"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 25\n",
    "@btime fibonacci(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  607.399 μs (1 allocation: 16 bytes)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "75025"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@btime fib(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collections and Data Structures\n",
    "\n",
    "In Dictionary Subtraction we used dictionaries to find the words that appear in a document but not in a word array. The function we wrote takes `d1`, which contains the words from the document as keys, and `d2`, which contains the array of words. It returns a dictionary that contains the keys from `d1` that are not in `d2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "subtract (generic function with 1 method)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function subtract(d1, d2)\n",
    "    res = Dict()\n",
    "    for key in keys(d1)\n",
    "        if key ∉ keys(d2)\n",
    "            res[key] = nothing\n",
    "        end\n",
    "    end\n",
    "    res\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In all of these dictionaries, the values are `nothing` because we never use them. As a result, we waste some storage space. Julia provides another built-in type, called a set, that behaves like a collection of dictionary keys with no values. Adding elements to a set is fast; so is checking membership. And sets provide functions and operators to compute common set operations. \n",
    "\n",
    "For example, set subtraction is available as a function called `setdiff`. So we can rewrite subtract like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "subtract (generic function with 1 method)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function subtract(d1, d2)\n",
    "    setdiff(d1, d2)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is a set instead of a dictionary.\n",
    "\n",
    "Some of the exercises in this book can be done concisely and efficiently with sets. For example, here is a solution to `hasduplicates`, from Exercise 10-7, that uses a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hasduplicates (generic function with 1 method)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function hasduplicates(t)\n",
    "    d = Dict()\n",
    "    for x in t\n",
    "        if x ∈ d\n",
    "            return true\n",
    "        end\n",
    "        d[x] = nothing\n",
    "    end\n",
    "    false\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When an element appears for the first time, it is added to the dictionary. If the same element appears again, the function returns `true`.\n",
    "\n",
    "Using sets, we can write the same function like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hasduplicates (generic function with 1 method)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function hasduplicates(t)\n",
    "    length(Set(t)) < length(t)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An element can only appear in a set once, so if an element in `t` appears more than once, the set will be smaller than `t`. If\n",
    "there are no duplicates, the set will be the same size as `t`.\n",
    "\n",
    "We can also use sets to do some of the exercises in Case Study: Word Play. For example, here’s a version of usesonly with\n",
    "a loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "usesonly (generic function with 1 method)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function usesonly(word, available)\n",
    "    for letter in word\n",
    "        if letter ∉ available\n",
    "            return false\n",
    "        end\n",
    "    end\n",
    "    true\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`usesonly` checks whether all letters in word are in `available`. We can rewrite it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "usesonly (generic function with 1 method)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function usesonly(word, available)\n",
    "    Set(word) ⊆ Set(available)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 20-1\n",
    "\n",
    "Rewrite avoids using sets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mathematics\n",
    "\n",
    "Complex numbers are also supported in Julia. The global constant `im` is bound to the complex number $i$, representing the principal square root of $-1$.\n",
    "\n",
    "We can now verify Euler’s identity,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0 + 1.2246467991473532e-16im"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ℯ^(im*π)+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The symbol ℯ ( \\euler TAB ) is the base of natural logarithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s illustrate the complex nature of trigonometric functions:\n",
    "\n",
    "$$\\cos(x) = \\frac{e^{ix} + e^{-ix}}{2}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 0:0.1:2π\n",
    "cos.(x) == 0.5*(ℯ.^(im*x)+ℯ.^(-im*x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, another example of the dot operator is shown. Julia also allows numeric literals to be juxtaposed with identifiers as\n",
    "coefficients as in 2π."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "\n",
    "In Strings and Case Study: Word Play, we did some elementary searches in string objects. Julia can handle however Perl compatible regular expressions (regexes), which eases the task of finding complex patterns in string objets. The usesonly function can be implemented as a regex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "usesonly (generic function with 1 method)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function usesonly(word, available)\n",
    "    r = Regex(\"[^$(available)]\")\n",
    "    !occursin(r, word)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The regex looks for a character that is not in the available string and occursin returns true if the pattern is found in\n",
    "`word`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "usesonly(\"banana\", \"abn\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "usesonly(\"bananas\", \"abn\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regexes can also be constructed as non-standard string literals prefixed with `r`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "match(r\"[^abn]\", \"banana\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RegexMatch(\"s\")"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = match(r\"[^abn]\", \"bananas\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String interpolation is not allowed in this case. The `match` function returns nothing if the pattern (a command) is not\n",
    "found and return a regexmatch object otherwise.\n",
    "\n",
    "We can extract the following info from a regexmatch object:\n",
    "\n",
    "* the entire substring matched: m.match\n",
    "* the captured substrings as an array of strings: m.captures\n",
    "* the offset at which the whole match begins: m.offset\n",
    "* the offsets of the captured substrings as an array: m.offsets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"s\""
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.match"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.offset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regexes are extremely powerful and the PERL manpage http://perldoc.perl.org/perlre.html provides all the details to\n",
    "construct the most exotic searches."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays\n",
    "\n",
    "In Arrays we used an array object as a one-dimensional container with an index to address its elements. In Julia however, arrays are multi-dimensional collections. \n",
    "\n",
    "Let’s create a 2-by-3 zero matrix:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Float64,2}:\n",
       " 0.0  0.0  0.0\n",
       " 0.0  0.0  0.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = zeros(Float64, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{Float64,2}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of this matrix is an array holding floating points and having 2 dimensions.\n",
    "\n",
    "The size function returns a tuple with as elements the number of elements in each dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `ones` constructs a matrix with unit value elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×3 Array{String,2}:\n",
       " \"\"  \"\"  \"\""
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = ones(String, 1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The string unit element is an empty string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning**: `s` is not a one-dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s == [\"\", \"\", \"\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`s` is a row matrix and [\"\", \"\", \"\"] is a column matrix."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A matrix can be entered directly using a space to separate elements in a row and a semicolon ; to separate rows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Int64,2}:\n",
       " 1  2  3\n",
       " 4  5  6"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1 2 3; 4 5 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use square brackets to address individual elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z[1,2] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z[2,3] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Float64,2}:\n",
       " 0.0  1.0  0.0\n",
       " 0.0  0.0  1.0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slices can be used for each dimension to select a subgroup of elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Array{Float64,2}:\n",
       " 1.0  0.0\n",
       " 0.0  1.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = z[:,2:end]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `.` operator broadcasts to all dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Array{Complex{Float64},2}:\n",
       " 0.540302+0.841471im       1.0+0.0im     \n",
       "      1.0+0.0im       0.540302+0.841471im"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ℯ.^(im*u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interfaces\n",
    "\n",
    "Julia specifies some informal interfaces to define behaviors, i.e. methods with a specific goal. When you extend such a method for a type, objects of that type can be used to build upon these behaviors.\n",
    "\n",
    "\"If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.\"\n",
    "\n",
    "In One More Example we implemented the fib function returning the n-th element of the Fibonnaci sequence. Looping over the values of a collection, called iteration, is such an interface.\n",
    "\n",
    "Let’s make an iterator that returns lazily the Fibonacci sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Fibonacci{T<:Real} end\n",
    "\n",
    "Fibonacci(d::DataType) = d<:Real ? Fibonacci{d}() : error(\"No Real type!\")\n",
    "\n",
    "Base.iterate(::Fibonacci{T}) where {T<:Real} = (zero(T), (one(T), one(T)))\n",
    "Base.iterate(::Fibonacci{T}, state::Tuple{T, T}) where {T<:Real} = (state[1], (state[2], state[1] + state[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We implemented a parametric type with no fields Fibonacci , an outer constructor and two methods iterate . The first is called to initialize the iterator and returns a tuple consisting of the first value, 0, and a state. The state in this case is a tuple containing the second and the third value, 1 and 1.\n",
    "\n",
    "The second is called to get the next value of the Fibonacci sequence and returns a tuple having as first element the next value and as second element the state which is a tuple with the two following values. \n",
    "\n",
    "We can use Fibonacci now in a for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 34 55 89 "
     ]
    }
   ],
   "source": [
    "for e in Fibonacci(Int64)\n",
    "    e > 100 && break\n",
    "    print(e, \" \")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like magic has happened but the explanation is simple. A for loop in Julia\n",
    "\n",
    "```\n",
    "for i in iter\n",
    "    # body\n",
    "end\n",
    "```\n",
    "\n",
    "is translated into:\n",
    "\n",
    "```\n",
    "next = iterate(iter)\n",
    "while next !== nothing\n",
    "    (i, state) = next\n",
    "    # body\n",
    "    next = iterate(iter, state)\n",
    "end\n",
    "```\n",
    "\n",
    "This is a great example how a well defined interface allows an implementation to use all the functions that are aware of the interface.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive Utilities\n",
    "\n",
    "We have already met the InteractiveUtils module in Debugging. The @which macro is only the tip of the iceberg. Julia code is transformed by the LLVM library to machinecode in multiple steps. We can directly visualize the output of each stage.\n",
    "\n",
    "Let’s give a simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "squaresum (generic function with 1 method)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function squaresum(a::Float64, b::Float64)\n",
    "    a^2 + b^2\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first step is to look at the lowered code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CodeInfo(\n",
       "\u001b[90m1 ─\u001b[39m %1 = Core.apply_type(Base.Val, 2)\n",
       "\u001b[90m│  \u001b[39m %2 = (%1)()\n",
       "\u001b[90m│  \u001b[39m %3 = Base.literal_pow(Main.:^, a, %2)\n",
       "\u001b[90m│  \u001b[39m %4 = Core.apply_type(Base.Val, 2)\n",
       "\u001b[90m│  \u001b[39m %5 = (%4)()\n",
       "\u001b[90m│  \u001b[39m %6 = Base.literal_pow(Main.:^, b, %5)\n",
       "\u001b[90m│  \u001b[39m %7 = %3 + %6\n",
       "\u001b[90m└──\u001b[39m      return %7\n",
       ")"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using InteractiveUtils\n",
    "@code_lowered squaresum(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The @code_lowered macro returns an array of an intermediate representation of the code that is used by the compiler to generate optimised code.\n",
    "\n",
    "The next step adds type information:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CodeInfo(\n",
       "\u001b[90m1 ─\u001b[39m %1 = Base.mul_float(a, a)\u001b[36m::Float64\u001b[39m\n",
       "\u001b[90m│  \u001b[39m %2 = Base.mul_float(b, b)\u001b[36m::Float64\u001b[39m\n",
       "\u001b[90m│  \u001b[39m %3 = Base.add_float(%1, %2)\u001b[36m::Float64\u001b[39m\n",
       "\u001b[90m└──\u001b[39m      return %3\n",
       ") => Float64"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@code_typed squaresum(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the type of the intermediate results and the return value is correctly inferred.\n",
    "\n",
    "This representation of the code is transformed into LLVM code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      ";  @ In[39]:2 within `squaresum'\n",
      "; Function Attrs: uwtable\n",
      "define double @julia_squaresum_17565(double, double) #0 {\n",
      "top:\n",
      "; ┌ @ intfuncs.jl:244 within `literal_pow'\n",
      "; │┌ @ float.jl:399 within `*'\n",
      "    %2 = fmul double %0, %0\n",
      "    %3 = fmul double %1, %1\n",
      "; └└\n",
      "; ┌ @ float.jl:395 within `+'\n",
      "   %4 = fadd double %2, %3\n",
      "; └\n",
      "  ret double %4\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "@code_llvm squaresum(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally the machine code is generated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t.text\n",
      "; ┌ @ In[39]:2 within `squaresum'\n",
      "\tpushq\t%rbp\n",
      "\tmovq\t%rsp, %rbp\n",
      "; │┌ @ intfuncs.jl:244 within `literal_pow'\n",
      "; ││┌ @ float.jl:399 within `*'\n",
      "\tvmulsd\t%xmm0, %xmm0, %xmm0\n",
      "\tvmulsd\t%xmm1, %xmm1, %xmm1\n",
      "; │└└\n",
      "; │┌ @ float.jl:395 within `+'\n",
      "\tvaddsd\t%xmm1, %xmm0, %xmm0\n",
      "; │└\n",
      "\tpopq\t%rbp\n",
      "\tretq\n",
      "\tnopw\t%cs:(%rax,%rax)\n",
      "; └\n"
     ]
    }
   ],
   "source": [
    "@code_native squaresum(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging\n",
    "\n",
    "The Logging macros provide an alternative to scaffolding with `print` statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "┌ Warning: Abandon printf debugging, all ye who enter here!\n",
      "└ @ Main In[44]:1\n"
     ]
    }
   ],
   "source": [
    "@warn \"Abandon printf debugging, all ye who enter here!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The debug statements don’t have to be removed from the source. For example, in contrast to the @warn above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "@debug \"The sum of some values $(sum(rand(100)))\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "will produce no output by default. In this case sum(rand(100)) will never be evaluated unless debug logging is enabled."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The level of logging can be selected by an environment variable `JULIA_DEBUG`.  On the terminal\n",
    "\n",
    "```\n",
    "JULIA_DEBUG=all julia -e '@debug \"The sum of some values $(sum(rand(100)))\"'\n",
    "\n",
    "```\n",
    "\n",
    "Here, we have used all to get all debug information, but you can also choose to generate only output for a specific file or\n",
    "module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.2.0",
   "language": "julia",
   "name": "julia-1.2"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}