01 introduction - 02 matrix reusability.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![JuliaLogo](https://julialang.org/assets/infra/logo.svg)\n",
    "# Welcome to the introductory tutorial to Julia\n",
    "This tutorial will lead you through the core features of Julia which enable huge reusability.\n",
    "\n",
    "This is a Juypter notebook which runs Julia as the kernel. You can actually interact with it, adapt code, and run code cells. You run cells and jump to the next by pressing SHIFT + ENTER. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Dispatch 101"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunc(a) = a\n",
    "myfunc(a::String) = \"$a - this is a string\"\n",
    "myfunc(a::Number) = a * a + 3\n",
    "myfunc(a::Rational)  = a // 11\n",
    "# multiline function definition\n",
    "function myfunc(a::AbstractArray)\n",
    "    inv(a)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunc(\"hi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunc(121//3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunc([1 2; 3 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunc(nothing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try the remaining clause"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Dispatch Connectivity Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a graph, and the cost to go from node $i$ to node $j$ is captured in a matrix entry $a_{ij}$, called adjency matrix.\n",
    "\n",
    "$${\\displaystyle \\mathbf {A} ={\\begin{pmatrix}a_{11}&a_{12}&\\cdots &a_{1n}\\\\a_{21}&a_{22}&\\cdots &a_{2n}\\\\\\vdots &\\vdots &\\ddots &\\vdots \\\\a_{m1}&a_{m2}&\\cdots &a_{mn}\\\\\\end{pmatrix}}}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using GraphRecipes, Plots\n",
    "connectivity = [\n",
    "    1 0 1\n",
    "    0 1 0\n",
    "    0 1 1\n",
    "]\n",
    "graphplot(connectivity, names=1:3, curvature_scalar=0.1, arrow=arrow(:closed, :head, 1, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use matrix product to find the shortest connection between all nodes.\n",
    "$$\\mathbf A^2 = \\mathbf A \\mathbf A$$\n",
    "$${\\displaystyle a^2_{ij}=\\sum _{k=1}^{n}a_{ik}a_{kj}} = a_{i1}a_{1j}+a_{i2}a_{2j}+\\cdots +a_{in}a_{nj}$$\n",
    "The definition of matrix multiplikation suggest that if we interprete \n",
    "* $\\sum$, `+` as take-the-best,\n",
    "* `*` as combine-both-sub-paths\n",
    "\n",
    "Then $a^2_{ij}$ stands for \"shortest past between node $i$ and node $j$ in $2$ steps\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 1: connected or not connected - Bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "connectivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "connectivity^2 .> 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2: shortest path - Cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Base: *, +  # we need to import a function in order to specialize it for new types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Cost{T}\n",
    "    value::T\n",
    "end\n",
    "# take-the-best:\n",
    "function *(a::Cost, b::Cost)\n",
    "    Cost(a.value + b.value)\n",
    "end\n",
    "# combine-both-sub-paths:\n",
    "function +(a::Cost, b::Cost)\n",
    "    if a.value < b.value\n",
    "        a\n",
    "    else\n",
    "        b\n",
    "    end\n",
    "end\n",
    "\n",
    "# or in short syntax:\n",
    "a::Cost * b::Cost = Cost(a.value + b.value)\n",
    "a::Cost + b::Cost = a.value < b.value ? a : b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "connectivity2 = [\n",
    "    0   Inf 2\n",
    "    Inf 0   Inf\n",
    "    Inf 2.4 0\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "connectivity2_cost = Cost.(connectivity2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "connectivity2_cost^2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measurements.jl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Measurements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1.0 ± 4.1 # \\pm is ±, also try out https://detexify.kirelabs.org/classify.html\n",
    "b = 3.4 ± 1.4\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "connectivity2_cost_measure = Cost.([\n",
    "    0   Inf       2 ± 4\n",
    "    Inf 0         Inf\n",
    "    Inf 2.4 ± 1   0\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = connectivity2_cost_measure^2\n",
    "result[1,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 3: Track path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an exercice for the interested participant, you can easily implement a custom data type which tracks the concrete shortest path.\n",
    "\n",
    "E.g. `result[1,2]` should somehow show that it needs to go from 1 to 3 to 2 respectively.\n",
    "\n",
    "Extra difficulty: You can even define this independently, so that given any Cost-like type, it will track the path. On the other hand if you want it a bit easier, just define your specific ``CostTrackPath`` custom type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct CostTrackPath{T}\n",
    "    value::T\n",
    "    path::Vector\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thanks for participating ;-)\n",
    "\n",
    "In case of any questions feel free to reach me at s.sahm@reply.de\n",
    "\n",
    "If you are curious for more or want to do a Julia project, just tell me. I am always glad about new enthusiasts.\n",
    "\n",
    "Believe me, it's the future of applied-math, including data-science.\n",
    "![fans](https://images.unsplash.com/photo-1429962714451-bb934ecdc4ec?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=2250&q=80)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.4.1",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}