julia/TinyTemperatureLibrary-Julia.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A Tiny Temperature Converter Library\n",
    "## Written in Julia (a naive approach)\n",
    "\n",
    "Based on a wonderful example from _Erik Engheim_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We start with some type definitions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "abstract type Temperature end\n",
    "\n",
    "struct Celsius <: Temperature\n",
    "    value::Float64\n",
    "end\n",
    "\n",
    "struct Kelvin <: Temperature\n",
    "   value::Float64 \n",
    "end\n",
    "\n",
    "struct Fahrenheit <: Temperature\n",
    "    value::Float64\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Define the promotion rules, so Julia knows our preferences when mixing types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "promote_rule (generic function with 126 methods)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Base: promote_rule  # we import the `promote_rule` function to add our own methods\n",
    "\n",
    "promote_rule(::Type{Kelvin}, ::Type{Celsius})     = Kelvin\n",
    "promote_rule(::Type{Fahrenheit}, ::Type{Celsius}) = Celsius\n",
    "promote_rule(::Type{Fahrenheit}, ::Type{Kelvin})  = Kelvin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We implement the conversion logic by adding methods to the `convert` function, available in the `Base` of Julia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "convert (generic function with 730 methods)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Base: convert  # again, we add our own methods to `convert`\n",
    "\n",
    "convert(::Type{Kelvin},  t::Celsius)     = Kelvin(t.value + 273.15)\n",
    "convert(::Type{Kelvin},  t::Fahrenheit)  = Kelvin(Celsius(t))\n",
    "convert(::Type{Celsius}, t::Kelvin)      = Celsius(t.value - 273.15)\n",
    "convert(::Type{Celsius}, t::Fahrenheit)  = Celsius((t.value - 32)*5/9)\n",
    "convert(::Type{Fahrenheit}, t::Celsius)  = Fahrenheit(t.value*9/5 + 32)\n",
    "convert(::Type{Fahrenheit}, t::Kelvin)   = Fahrenheit(Celsius(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can add some nice constructors, so we can initialise each "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fahrenheit"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Kelvin(t::Temperature) = convert(Kelvin, t)\n",
    "Celsius(t::Temperature) = convert(Celsius, t)\n",
    "Fahrenheit(t::Temperature) = convert(Fahrenheit, t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Kelvin(268.15)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Kelvin(Fahrenheit(23))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Adding arithmetic operations for our types by extending the `Base` operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import Base: +, -, *  # operators are functions, we can extend them easily!\n",
    "\n",
    "+(x::Temperature, y::Temperature) = +(promote(x,y)...)\n",
    "-(x::Temperature, y::Temperature) = -(promote(x,y)...)\n",
    "\n",
    "+(x::T, y::T) where {T <: Temperature} = T(x.value + y.value)\n",
    "-(x::T, y::T) where {T <: Temperature} = T(x.value - y.value)\n",
    "\n",
    "*(x::Number, y::T) where {T <: Temperature} = T(x * y.value);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let's test it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Kelvin(320.15)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Celsius(37) + Kelvin(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Celsius(47.0)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Celsius(Celsius(37) + Kelvin(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Kelvin(305.15)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Fahrenheit(23) + Celsius(42) - Kelvin(5)  # this does not need to make sense now ;)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A nice way to create some syntactic sugar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "const °C = Celsius(1)\n",
    "const °F = Fahrenheit(1)\n",
    "const K = Kelvin(1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Fahrenheit(5.0), Kelvin(23.0), Celsius(42.0))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5°F, 23K, 42°C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Kelvin(325.15)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42°C + 10K"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Alright, let's have a look behind the scenes..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "example_calculation (generic function with 1 method)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_calculation() = Fahrenheit(2) + Celsius(3) + Kelvin(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "define %Kelvin @julia_example_calculation_62940() #0 !dbg !5 {\n",
      "top:\n",
      "  ret %Kelvin { double 0x407077BBBBBBBBBB }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "@code_llvm example_calculation()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "LLVM figured out that the function returns always the same value... Dooh ;)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This is the \"machine code\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t.section\t__TEXT,__text,regular,pure_instructions\n",
      "Filename: In[13]\n",
      "\tpushl\t%ebp\n",
      "\tdecl\t%eax\n",
      "\tmovl\t%esp, %ebp\n",
      "\tdecl\t%eax\n",
      "\tmovl\t$478589824, %eax        ## imm = 0x1C86B380\n",
      "\taddl\t%eax, (%eax)\n",
      "\taddb\t%al, (%eax)\n",
      "Source line: 1\n",
      "\tmovsd\t(%eax), %xmm0           ## xmm0 = mem[0],zero\n",
      "\tpopl\t%ebp\n",
      "\tretl\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n"
     ]
    }
   ],
   "source": [
    "@code_native example_calculation()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Now a function which is not constant ;)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "another_calculation (generic function with 1 method)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "another_calculation(a, b, c) = Fahrenheit(a) + Celsius(b) + Kelvin(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "define %Kelvin @julia_another_calculation_62960(i64, i64, i64) #0 !dbg !5 {\n",
      "top:\n",
      "  %3 = sitofp i64 %0 to double\n",
      "  %4 = fadd double %3, -3.200000e+01\n",
      "  %5 = fmul double %4, 5.000000e+00\n",
      "  %6 = fdiv double %5, 9.000000e+00\n",
      "  %7 = sitofp i64 %1 to double\n",
      "  %8 = fadd double %7, %6\n",
      "  %9 = fadd double %8, 2.731500e+02\n",
      "  %10 = sitofp i64 %2 to double\n",
      "  %11 = fadd double %10, %9\n",
      "  %12 = insertvalue %Kelvin undef, double %11, 0\n",
      "  ret %Kelvin %12\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "@code_llvm another_calculation(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "And the machine code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t.section\t__TEXT,__text,regular,pure_instructions\n",
      "Filename: In[16]\n",
      "\tpushl\t%ebp\n",
      "\tdecl\t%eax\n",
      "\tmovl\t%esp, %ebp\n",
      "\tdecl\t%eax\n",
      "\tmovl\t$478594312, %eax        ## imm = 0x1C86C508\n",
      "\taddl\t%eax, (%eax)\n",
      "\taddb\t%al, (%eax)\n",
      "Source line: 1\n",
      "\taddsd\t(%eax), %xmm0\n",
      "\tdecl\t%eax\n",
      "\tmovl\t$478594320, %eax        ## imm = 0x1C86C510\n",
      "\taddl\t%eax, (%eax)\n",
      "\taddb\t%al, (%eax)\n",
      "\tmulsd\t(%eax), %xmm0\n",
      "\tdecl\t%eax\n",
      "\tmovl\t$478594328, %eax        ## imm = 0x1C86C518\n",
      "\taddl\t%eax, (%eax)\n",
      "\taddb\t%al, (%eax)\n",
      "\tdivsd\t(%eax), %xmm0\n",
      "\taddsd\t%xmm1, %xmm0\n",
      "\tdecl\t%eax\n",
      "\tmovl\t$478594336, %eax        ## imm = 0x1C86C520\n",
      "\taddl\t%eax, (%eax)\n",
      "\taddb\t%al, (%eax)\n",
      "\taddsd\t(%eax), %xmm0\n",
      "\taddsd\t%xmm2, %xmm0\n",
      "\tpopl\t%ebp\n",
      "\tretl\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n",
      "\tnop\n"
     ]
    }
   ],
   "source": [
    "@code_native another_calculation(2.0, 3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What about the actual performance?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "using BenchmarkTools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     1.901 ns (0.00% GC)\n",
       "  median time:      1.903 ns (0.00% GC)\n",
       "  mean time:        2.059 ns (0.00% GC)\n",
       "  maximum time:     32.996 ns (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     1000"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark another_calculation(2.0, 3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can easily define our own `rand` method for `Kelvin` temperatures ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000000-element Array{Kelvin,1}:\n",
       " Kelvin(786.699)\n",
       " Kelvin(3526.04)\n",
       " Kelvin(2836.04)\n",
       " Kelvin(1070.38)\n",
       " Kelvin(2469.57)\n",
       " Kelvin(1652.41)\n",
       " Kelvin(561.549)\n",
       " Kelvin(4913.06)\n",
       " Kelvin(1774.79)\n",
       " Kelvin(478.199)\n",
       " Kelvin(349.99) \n",
       " Kelvin(1994.88)\n",
       " Kelvin(4737.78)\n",
       " ⋮              \n",
       " Kelvin(1455.66)\n",
       " Kelvin(1745.72)\n",
       " Kelvin(3667.81)\n",
       " Kelvin(2814.69)\n",
       " Kelvin(158.547)\n",
       " Kelvin(482.548)\n",
       " Kelvin(386.658)\n",
       " Kelvin(525.919)\n",
       " Kelvin(3973.32)\n",
       " Kelvin(4017.23)\n",
       " Kelvin(547.849)\n",
       " Kelvin(2464.27)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Base: rand\n",
    "\n",
    "rand(::MersenneTwister, ::Type{Kelvin}) = Kelvin(rand() * 5000)\n",
    "\n",
    "temperatures = rand(Kelvin, 1_000_000)  # one million values in Kelvin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Is this fast?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  7.63 MiB\n",
       "  allocs estimate:  2\n",
       "  --------------\n",
       "  minimum time:     8.569 ms (0.00% GC)\n",
       "  median time:      10.443 ms (0.00% GC)\n",
       "  mean time:        11.180 ms (10.39% GC)\n",
       "  maximum time:     73.797 ms (87.44% GC)\n",
       "  --------------\n",
       "  samples:          447\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark rand(Kelvin, 1_000_000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Yep... 10ms, 2 allocs, 8 MiB memory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Convert them to `Celsius` by using our type constructor and the `.`-notation for element-wise operation (similar to Matlab or `ufuncs` in numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000000-element Array{Celsius,1}:\n",
       " Celsius(513.549) \n",
       " Celsius(3252.89) \n",
       " Celsius(2562.89) \n",
       " Celsius(797.23)  \n",
       " Celsius(2196.42) \n",
       " Celsius(1379.26) \n",
       " Celsius(288.399) \n",
       " Celsius(4639.91) \n",
       " Celsius(1501.64) \n",
       " Celsius(205.049) \n",
       " Celsius(76.8398) \n",
       " Celsius(1721.73) \n",
       " Celsius(4464.63) \n",
       " ⋮                \n",
       " Celsius(1182.51) \n",
       " Celsius(1472.57) \n",
       " Celsius(3394.66) \n",
       " Celsius(2541.54) \n",
       " Celsius(-114.603)\n",
       " Celsius(209.398) \n",
       " Celsius(113.508) \n",
       " Celsius(252.769) \n",
       " Celsius(3700.17) \n",
       " Celsius(3744.08) \n",
       " Celsius(274.699) \n",
       " Celsius(2191.12) "
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Celsius.(temperatures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Is this fast?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  7.63 MiB\n",
       "  allocs estimate:  26\n",
       "  --------------\n",
       "  minimum time:     2.411 ms (0.00% GC)\n",
       "  median time:      3.805 ms (0.00% GC)\n",
       "  mean time:        4.762 ms (27.86% GC)\n",
       "  maximum time:     75.720 ms (96.37% GC)\n",
       "  --------------\n",
       "  samples:          1044\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark Celsius.(temperatures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Yep... 2.7ms, 26 allocs, 8 MiB memory"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Julia 0.6.3",
   "language": "julia",
   "name": "julia-0.6"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}