Day1/13_julia-practical-on-jupyter/output/13_julia-practical-on-jupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Practical introduction to Julia-basics\n",
    "\n",
    "We will cover:\n",
    "- some more introduction\n",
    "- docs\n",
    "- variables\n",
    "- datatypes\n",
    "- arrays (longer exercise)\n",
    "- flow control (small exercise)\n",
    "- functions (larger exercise)\n",
    "- multiple dispatch\n",
    "- modules and packages"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Aside 1: Jupyter Notebooks\n",
    "\n",
    "These slides are a [Jupyter notebook](https://jupyter.org/); a browser-based computational notebook.\n",
    "\n",
    "Code cells are executed by putting the cursor into the cell and hitting `shift + enter`.  For more\n",
    "info see the [documentation](https://jupyter-notebook.readthedocs.io/en/stable/)."
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Aside 2: What is your previous programming experience?\n",
    "\n",
    "1. Matlab/Octave\n",
    "2. Python\n",
    "3. R\n",
    "4. other scripting languages (IDL, Mathematica, Perl...)\n",
    "5. C, Fortran, ...\n",
    "6. Pascal, Java, C++, ...\n",
    "7. Lisp, Haskell, Assembler, Coq ...\n",
    "\n",
    "(no prior programming experience?)"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### What does Julia look like\n",
    "\n",
    "Revisiting the Lorenz system of ODEs:"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "using OrdinaryDiffEq, Plots\n",
    "\n",
    "function lorenz(x, p, t)\n",
    "    σ = 10\n",
    "    β = 8/3\n",
    "    ρ = 28\n",
    "    [σ*(x[2]-x[1]),\n",
    "     x[1]*(ρ-x[3]) - x[2],\n",
    "     x[1]*x[2] - β*x[3]]\n",
    "end\n",
    "\n",
    "# integrate dx/dt = lorenz(t,x) numerically from t=0 to t=50 and starting point x₀\n",
    "tspan = (0.0, 50.0)\n",
    "x₀ = [2.0, 0.0, 0.0]\n",
    "sol = solve(ODEProblem(lorenz, x₀, tspan), Tsit5()); # the ; suppresses the output"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Yes, this takes some time... Julia is Just-Ahead-of-Time compiled.  I.e. Julia is compiling."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "And its solution plotted"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "plot(sol, idxs=(1,2,3)) # plot Lorenz attractor"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "###  Let's get our hands dirty!\n",
    "\n",
    "Steps:\n",
    "1) download this notebook & the `Project.toml` file (clone it, download them, etc.)\n",
    "   - find in in `WSLJuliaWorkshop2023/Day1/13_julia-practical-on-jupyter/output/`\n",
    "2) start Jupyter in the folder containing the two files:\n",
    "   - at the command prompt `jupyter notebook`\n",
    "   - in the Julia REPL `julia> using IJulia; notebook()`\n",
    "3) open notebook `13_julia-practical-on-jupyter.ipynb` in browser"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "--> everyone got it running?"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "fragment"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "###  Let's get our hands dirty!\n",
    "\n",
    "We will now look at\n",
    "- using Jupyter notebooks\n",
    "- querying and getting Julia documentation\n",
    "- variables and types\n",
    "- control flow\n",
    "- functions\n",
    "- modules and packages"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "###  Where are the docs?\n",
    "\n",
    "The documentation of Julia is good and can be found at [https://docs.julialang.org](https://docs.julialang.org); although for learning it might be a bit terse...\n",
    "\n",
    "There are also tutorials, see [https://julialang.org/learning/](https://julialang.org/learning/); in case we don't cover something\n",
    "\n",
    "Help on functions, variables, etc. can be gotten with `?xyz` (execute it in a cell by itself)"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "# ?cos"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "###  DO: Get help on π (pi)\n",
    "\n",
    "- what is it\n",
    "- incidentally, how can you use unicode variables?"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Variables, assignments, and types\n",
    "[https://docs.julialang.org/en/v1/manual/variables/](https://docs.julialang.org/en/v1/manual/variables/)"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a = 4\n",
    "b = \"a string\"\n",
    "c = b # now b and c bind to the same value"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Conventions:\n",
    "- variables are (usually) lowercase, words can be separated by `_`\n",
    "- function names are lowercase\n",
    "- modules, packages and types are in CamelCase"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Variables: Unicode continued\n",
    "From [https://docs.julialang.org/en/v1/manual/variables/](https://docs.julialang.org/en/v1/manual/variables/):\n",
    "\n",
    "Unicode names (in UTF-8 encoding) are allowed:\n",
    "\n",
    "```julia\n",
    "julia> δ = 0.00001\n",
    "1.0e-5\n",
    "\n",
    "julia> 안녕하세요 = \"Hello\"\n",
    "\"Hello\"\n",
    "```\n",
    "\n",
    "In the Julia REPL and several other Julia editing environments, you can type many Unicode math\n",
    "symbols by typing the backslashed LaTeX symbol name followed by tab. For example, the variable\n",
    "name `δ` can be entered by typing `\\delta`-*tab*, or even `α̂⁽²⁾` by `\\alpha`-*tab*-`\\hat`-\n",
    "*tab*-`\\^(2)`-*tab*. (If you find a symbol somewhere, e.g. in someone else's code,\n",
    "that you don't know how to type, the REPL help will tell you: just type `?` and\n",
    "then paste the symbol.)"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Basic datatypes\n",
    "- numbers (Ints, Floats, Complex, etc.)\n",
    "- strings\n",
    "- tuples\n",
    "- arrays\n",
    "- dictionaries"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "1     # 64 bit integer (or 32 bit if on a 32-bit OS)\n",
    "1.5   # Float64\n",
    "1//2  # Rational"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "typeof(1.5)"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "\"a string\", (1, 3.5) # and tuple"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "[1, 2, 3,] # array of eltype Int"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "Dict(\"a\"=>1, \"b\"=>cos)"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Array exercises\n",
    "\n",
    "We all use arrays extensively.\n",
    "\n",
    "Datatypes belonging to AbstactArrays:\n",
    "- `Array` (with aliases `Vector`, `Matrix`)\n",
    "- `Range`\n",
    "- GPU arrays, static arrays, Rasters (geo-data-arrays), etc"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Task: assign two vectors to `a`, and `b` and the concatenate them using `;`:"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a = [2, 3]\n",
    "b = ...\n",
    "[ ; ]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Add new elements to a empty Vector `c` (hint look up the documentation for `push!`)\n",
    "((`push!` only works on Vectors, i.e. 1D arrays))"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "c = []\n",
    "..."
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Array exercises\n",
    "\n",
    "Concatenate a Range, say `1:10`, with a Vector, say [4,5]:"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "[  ;  ]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Make a random array of size (3,3).  Look up `?rand`.  Assign it to `a`"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Array exercise: indexing\n",
    "\n",
    "**Indexing starts at 1!**\n",
    "\n",
    "Access element `[1,2]` and `[2,1]` of Matrix `a` (hint use []):"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a[ ... ], a[ ... ]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Put those two values into a vector"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Linear vs Cartesian indexing,\n",
    "access the first element:"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a[1]\n",
    "a[1,1]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Access the last element (look up `?end`) both with linear and Cartesian indices"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a[...]\n",
    "a[..., ...]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Array exercise: indexing by ranges\n",
    "\n",
    "Access the last row of `a` (hint use `1:end`)"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a[... , ...]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Access a 2x2 sub-matrix"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a[ ]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Array exercises: variable bindings and views\n",
    "\n",
    "What do you make of"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a = [1 4; 3 4] # note, this is another way to define a Matrix\n",
    "c = a\n",
    "a[1, 2] = 99\n",
    "@assert c[1,2] == a[1,2]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Type your answer here (to start editing, double click into this cell.  When done shift+enter):"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Side-trip: macros\n",
    "\n",
    "Macros, starting with `@`, work on the code itself and not the values as usual functions.\n",
    "\n",
    "In general you don't need to care how they work, just use them.\n",
    "\n",
    "Useful macros:"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "@assert 1==1 # checks that expression evaluates to true, otherwise errors\n",
    "\n",
    "@time 1+1 # times how long the execution takes\n",
    "\n",
    "@show a # prints the value of a.  Useful for simple debugging: put @show into your functions"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Array exercises: variable bindings and views\n",
    "\n",
    "An assignment _binds_ the same array to both variables"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "c = a\n",
    "c[1] = 8\n",
    "@assert a[1]==8 # as c and a are the same thing\n",
    "@assert a===c  # note the triple `=` meaning \"identical\""
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Views vs copies:\n",
    "\n",
    "In Julia indexing with ranges will create a new array with copies of\n",
    "the original's entries (similar to Matlab, unlike Python). Consider"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a = rand(3,4)\n",
    "b = a[1:3, 1:2]\n",
    "b[1] = 99\n",
    "@assert a[1] != b[1]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Array exercises: variable bindings and views\n",
    "\n",
    "But the memory footprint will be large if we work with large arrays and take sub-arrays of them.\n",
    "\n",
    "\"Views\" to the rescue (note: another macro)"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a = rand(3,4)\n",
    "b = @view a[1:3, 1:2]\n",
    "b[1] = 99"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "check whether the change in `b` is reflected in `a`:"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "@assert ..."
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Side-trip: types\n",
    "\n",
    "All values have types as we saw above.  Arrays store in their type what type the elements can be.\n",
    "\n",
    "> Arrays which have concrete element-types are more performant!"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "typeof([1, 2]), typeof([1.0, 2.0])"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Aside, they also store their dimension in the second parameter.\n",
    "\n",
    "The type can be specified at creation"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "String[\"one\", \"two\"]"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Create an array taking `Int` with no elements.  Push `1`, `1.0` and `1.5` to it.  What happens?"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Make an array of type `Any` (which can store any value).  Push a value of type\n",
    "Int and one of type String to it."
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Try to assgin 1.5 to the first element of an array of type Array{Int,1}"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Array exercises\n",
    "\n",
    "Create a uninitialised Matrix of size (3,3) and assign it to `a`.\n",
    "First look up the docs of Array with `?Array`"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Test that its size is correct, see `size`"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Array exercises: ALL DONE\n",
    "\n",
    "The rest about Arrays you will learn-by-doing during the rest of the workshop."
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Control flow\n",
    "\n",
    "Julia provides a variety of [control flow constructs](https://docs.julialang.org/en/v1/manual/control-flow/), of which we look at:\n",
    "\n",
    "  * [Conditional Evaluation](https://docs.julialang.org/en/v1/manual/control-flow/#man-conditional-evaluation): `if`-`elseif`-`else` and `?:` (ternary operator).\n",
    "  * [Short-Circuit Evaluation](https://docs.julialang.org/en/v1/manual/control-flow/#Short-Circuit-Evaluation): logical operators `&&` (“and”) and `||` (“or”), and also chained comparisons.\n",
    "  * [Repeated Evaluation: Loops](https://docs.julialang.org/en/v1/manual/control-flow/#man-loops): `while` and `for`.\n",
    "  * [Exception-Handling](https://docs.julialang.org/en/v1/manual/control-flow/#Exception-Handling): `throw`ing exception, `try`/`catch` blocks"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Conditional evaluation\n",
    "\n",
    "Read the first paragraph of\n",
    "[https://docs.julialang.org/en/v1/manual/control-flow/#man-conditional-evaluation](https://docs.julialang.org/en/v1/manual/control-flow/#man-conditional-evaluation)\n",
    "(up to \"... and no further condition expressions or blocks are evaluated.\")"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Write a test which looks at the start of the string in variable `a`\n",
    "(?startswith) and sets `b` accordingly.  If the start is\n",
    "- \"Wh\" then set `b = \"Likely a question\"`\n",
    "- \"The \" then set `b = \"A noun\"`\n",
    "- otherwise set `b = \"no idea\"`"
   ],
   "metadata": {}
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Conditional evaluation: the \"ternary operator\" `?`\n",
    "\n",
    "Look up the docs for `?` (i.e. evaluate `??`)\n",
    "\n",
    "Re-write using `?`\n",
    "```\n",
    "a = rand() * 10\n",
    "if a > 5\n",
    "    \"really big\"\n",
    "else\n",
    "    \"not so big\"\n",
    "end\n",
    "```"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "a = rand() * 10\n",
    "..."
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Short circuit operators `&&` and `||`\n",
    "\n",
    "Read [https://docs.julialang.org/en/v1/manual/control-flow/#Short-Circuit-Evaluation](https://docs.julialang.org/en/v1/manual/control-flow/#Short-Circuit-Evaluation)\n",
    "\n",
    "Explain what this does\n",
    "\n",
    "```\n",
    "a < 0 && error(\"Not valid input for `a`\")\n",
    "```"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Type your answer here (to start editing, double click into this cell.  When done shift+enter):"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Loops: `for` and `while`\n",
    "\n",
    "[https://docs.julialang.org/en/v1/manual/control-flow/#man-loops](https://docs.julialang.org/en/v1/manual/control-flow/#man-loops)"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "for i = 1:3\n",
    "    println(i)\n",
    "end\n",
    "\n",
    "for i in [\"dog\", \"cat\"] ## `in` and `=` are equivalent for writing loops\n",
    "    println(i)\n",
    "end\n",
    "\n",
    "i = 1\n",
    "while i<4\n",
    "    println(i)\n",
    "    global i += 1\n",
    "end"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Functions\n",
    "\n",
    "Functions can be defined in Julia in a number of ways.  In particular there is one variant\n",
    "more suited to longer definitions, and one for one-liners:\n",
    "\n",
    "```\n",
    "function f(a, b)\n",
    "   a * b\n",
    "end\n",
    "f(a, b) = a * b\n",
    "```\n",
    "\n",
    "Defining many, short functions is typical in good Julia code.\n",
    "\n",
    "Read [https://docs.julialang.org/en/v1/manual/functions/](https://docs.julialang.org/en/v1/manual/functions/) up to an including \"The return Keyword\""
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Functions: exercises\n",
    "\n",
    "Define a function in long-form which takes two arguments.\n",
    "Use some if-else statements and the return keyword."
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Functions: exercises\n",
    "\n",
    "Re-define the `map` function.  First look up what it does `?map`, then create a `mymap` which\n",
    "does the same.  Map `sin` over the vector `1:10`.\n",
    "\n",
    "(Note, this is a higher-order function: a function which take a function as a argument)"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "#"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Functions: dot-syntax\n",
    "\n",
    "This is really similar to the `map` function, a short-hand to map/broadcast a\n",
    "function over values.\n",
    "\n",
    "Example:"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "sin.(1:10)"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "--> more about this in the afternoon"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Functions: anonymous functions\n",
    "\n",
    "So far our function got a name with the definition. They can also be defined without name.\n",
    "\n",
    "Read [https://docs.julialang.org/en/v1/manual/functions/#man-anonymous-functions](https://docs.julialang.org/en/v1/manual/functions/#man-anonymous-functions)\n",
    "\n",
    "Map the function `f(x,y) = sin(x) + cos(x)` over `1:10` but define `f` as an anonymous\n",
    "function."
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "map(..., 1:10)"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Key feature: multiple dispatch functions\n",
    "\n",
    "- Julia is not an object oriented language\n",
    "\n",
    "OO:\n",
    "- methods belong to objects\n",
    "- method is selected based on first argument (e.g. `self` in Python)\n",
    "\n",
    "Multiple dispatch:\n",
    "- methods are separate from objects\n",
    "- are selected based on all arguments\n",
    "- similar to overloading but method selection occurs at runtime and not compile-time (see also video below)\n",
    "> very natural for mathematical programming\n",
    "\n",
    "JuliaCon 2019 presentation on the subject by Stefan Karpinski\n",
    "(co-creator of Julia):\n",
    "\n",
    "[\"The Unreasonable Effectiveness of Multiple Dispatch\"](https://www.youtube.com/watch?v=kc9HwsxE1OY)"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Functions: Multiple dispatch demo"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "struct Rock end\n",
    "struct Paper end\n",
    "struct Scissors end\n",
    "### of course structs could have fields as well\n",
    "# struct Rock\n",
    "#     color\n",
    "#     name::String\n",
    "#     density::Float64\n",
    "# end\n",
    "\n",
    "# define multi-method\n",
    "play(::Rock, ::Paper) = \"Paper wins\"\n",
    "play(::Rock, ::Scissors) = \"Rock wins\"\n",
    "play(::Scissors, ::Paper) = \"Scissors wins\"\n",
    "play(a, b) = play(b, a) # commutative\n",
    "\n",
    "play(Scissors(), Rock())"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Multiple dispatch demo\n",
    "Can easily be extended later\n",
    "\n",
    "with new type:"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "struct Pond end\n",
    "play(::Rock, ::Pond) = \"Pond wins\"\n",
    "play(::Paper, ::Pond) = \"Paper wins\"\n",
    "play(::Scissors, ::Pond) = \"Pond wins\"\n",
    "\n",
    "play(Scissors(), Pond())"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "with new function:"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "fragment"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "combine(::Rock, ::Paper) = \"Paperweight\"\n",
    "combine(::Paper, ::Scissors) = \"Two pieces of papers\"\n",
    "# ...\n",
    "\n",
    "combine(Rock(), Paper())"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "*Multiple dispatch makes Julia packages very composable!*\n",
    "\n",
    "This is a key characteristic of the Julia package ecosystem."
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "fragment"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Modules and packages\n",
    "\n",
    "Modules can be used to structure code into larger entities, and be used to divide it into\n",
    "different name spaces.  We will not make much use of those, but if interested see\n",
    "[https://docs.julialang.org/en/v1/manual/modules/](https://docs.julialang.org/en/v1/manual/modules/)\n",
    "\n",
    "**Packages** are the way people distribute code and we'll make use of them extensively.\n",
    "In the first example, the Lorenz ODE, you saw\n",
    "```\n",
    "using OrdinaryDiffEq, Plots\n",
    "```\n",
    "This statement loads the two packages `OrdinaryDiffEq` and `Plots` and makes their functions\n",
    "and types available in the current session."
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "slide"
    }
   }
  },
  {
   "outputs": [],
   "cell_type": "code",
   "source": [
    "using Plots\n",
    "plot( (1:10).^2 )"
   ],
   "metadata": {},
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Packages\n",
    "\n",
    "Packages are in a sense Modules which you can install and then use.\n",
    "\n",
    "All public Julia packages are listed on [https://juliahub.com/ui/Packages](https://juliahub.com/ui/Packages).\n",
    "\n",
    "You can install a package, say `UnPack.jl` by\n",
    "```\n",
    "using Pkg\n",
    "Pkg.add(\"UnPack.jl\")\n",
    "using UnPack\n",
    "```\n",
    "\n",
    "In the REPL, there is also a package-mode (hit `]`) which is for interactive use.\n",
    "\n",
    "--> more about this later in the workshop"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## This concludes the rapid Julia tour\n",
    "\n",
    "There are many more features of Julia for sure but this should get you started for\n",
    "the workshop.\n",
    "\n",
    "Remember you can self-help with:\n",
    "- using `?` at the notebook or REPL.  Similarly there is an `apropos` function.\n",
    "- the docs are your friend [https://docs.julialang.org/en/v1/](https://docs.julialang.org/en/v1/)\n",
    "- ask us for help!"
   ],
   "metadata": {
    "name": "A slide ",
    "slideshow": {
     "slide_type": "subslide"
    }
   }
  }
 ],
 "nbformat_minor": 3,
 "metadata": {
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.3"
  },
  "kernelspec": {
   "name": "julia-1.8",
   "display_name": "Julia 1.8.3",
   "language": "julia"
  }
 },
 "nbformat": 4
}