1-JuliaBasics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Basic Julia\n",
    "\n",
    "In the first section we will overview basic Julia syntax, data structures, etc. If you are feel quite advanced in programming already feel free to wonder around until we get to the second section, which is about writing performant code.\n",
    "\n",
    "## Syntax and unicode\n",
    "\n",
    "1. Assingment in Julia is done with the `=` sign. \n",
    "- You can assign *anything* to a variable binding.\n",
    "- The variable names can include pretty much any Unicode character.\n",
    "- Strings are created between double quotes `\"` while the single quotes `'` are used for characters only.\n",
    "- Most Julia editors offer \"LaTeX Completion\". Pressing e.g. `\\delta` and then TAB will create the corresponding Unicode character using the LaTeX syntax.\n",
    "- **All Julia operations return a value**. This includes assingment.\n",
    "\n",
    "Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.588457268119896"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = x ^ 2.5 # powers with ^"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"αbasf\""
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "δ = \"αbasf\" # type \\delta and then press TAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 0, -1)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "😺, 😀, 😞 = 1, 0, -1 # do e.g. \\:smile: <TAB>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "😺 + 😞 == 😀"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since assignement returns the value, by default this value is printed. This is **AMAZING**, but you can also silence printing by adding `;` to the end of the expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most julia operators have their `=` version, which updates something with its own value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x += 3 # x = x + 3\n",
    "x -= 3\n",
    "x *=2\n",
    "x /= 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Literal numbers can multiply anything without having to put `*` inbetween, as long as the number is on the left side:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14.99296274685088"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5x - 12.54y * 1.2e-5x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Everything that exists in Julia has a certain **Type**. (e.g. numbers can be integers, floats, rationals). This is extremely important, and a core reason of the language's performance (more on Types on the second session).\n",
    "\n",
    "To find the type of a thing in Julia you simply use `typeof(thing)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(😺)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "String"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(\"asdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, you can interpolate any expression into a string using `$(expression)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"the value of the cat face (😺) is 1\""
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"the value of the cat face (😺) is $(😺)\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I am doing math inside a string: 240.0\""
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I am doing math inside a string: $(y^2 - x)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic collections\n",
    "\n",
    "Indexing a collection (like an array or a dictionary) in Julia is done with brackets: `collection[index]`. The `index` is typically an integer, although some structures can have arbitrary indices (like a dictionary), and you can define any indexing type for any collection you want (bit advanced tho').\n",
    "\n",
    "**Julia indexing starts from 1**\n",
    "\n",
    "### Tuples\n",
    "Tuples are ordered immutable collections of elements. They are mostly used when the elements are not of the same type with each other and are intended for small collections.\n",
    "\n",
    "Syntax:\n",
    "\n",
    "```julia\n",
    "(item1, item2, ...)```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"purple\", \"cats\", π)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfavoritethings = (\"purple\", \"cats\", π)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"purple\""
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfavoritethings[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NamedTuples\n",
    "\n",
    "These are exactly like tuples but also assign a name to each variable they contain. They rest between the `Tuple` and `Dict` type in their use.\n",
    "\n",
    "Their syntax is:\n",
    "```julia\n",
    "(key1 = val1, key2 = val2, ...)\n",
    "```\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(x = 5, y = \"str\", z = 1.6666666666666667)"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nt = (x = 5, y = \"str\", z = 5/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These objects can be accessed with `[1]` like normal tuples, but also with the syntax `.key`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nt[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nt.x # nt[:x]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "Dictionaries are unordered mutable collections of pairs key-value. They are intended for sets of relational data, and typically you want the data to be of the same type. Dictionaries have a specific type for keys and values.\n",
    "\n",
    "Syntax:\n",
    "```julia\n",
    "Dict(key1 => value1, key2 => value2, ...)```\n",
    "\n",
    "A good example of a dictionary is a contacts list, where we associate names with phone numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String,String} with 2 entries:\n",
       "  \"Jenny\"        => \"867-5309\"\n",
       "  \"Ghostbusters\" => \"555-2368\""
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myphonebook = Dict(\"Jenny\" => \"867-5309\", \"Ghostbusters\" => \"555-2368\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"867-5309\""
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myphonebook[\"Jenny\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "New entries can be added to the above dictionary, because it is mutable *(I will talk in more detail about mutability in a moment, but for now mutable means that \"you can change its values\")*. The key of the entry must be of type `String` and the value of the entry must be of type `String`, because these are the types in the original dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String,String} with 3 entries:\n",
       "  \"Jenny\"         => \"867-5309\"\n",
       "  \"BuzzLightyear\" => \"∞ and beyond\"\n",
       "  \"Ghostbusters\"  => \"555-2368\""
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myphonebook[\"BuzzLightyear\"] = \"∞ and beyond\"\n",
    "\n",
    "myphonebook # this displays the phonebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays\n",
    "\n",
    "The standard Julia `Array` is a mutable and ordered collection of items of the same type.\n",
    "The dimensionality of the Julia array is important. A `Matrix` is an array of dimension 2. A `Vector` is an array of dimension 1. The *element type* of what an array contains is irrelevant to its dimension!\n",
    "\n",
    "**i.e. a Vector of Vectors of Numbers and a Matrix of Numbers are two totally different things!**\n",
    "\n",
    "Syntax: <br>\n",
    "```julia\n",
    "[item1, item2, ...]```\n",
    "\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Array{String,1}:\n",
       " \"Ted\"     \n",
       " \"Robyn\"   \n",
       " \"Barney\"  \n",
       " \"Lily\"    \n",
       " \"Marshall\""
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfriends = [\"Ted\", \"Robyn\", \"Barney\", \"Lily\", \"Marshall\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Int64,1}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci = [1, 1, 2, 3, 5, 8, 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6-element Array{Any,1}:\n",
       " 1       \n",
       " 1       \n",
       " 2       \n",
       " 3       \n",
       "  \"Ted\"  \n",
       "  \"Robyn\""
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mixture = [1, 1, 2, 3, \"Ted\", \"Robyn\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned, the type of the elements of an array must be the same. Yet above we mix numbers with strings! I wasn't lying though; the above array is an **unoptimized** version that can hold **any** thing. You can see this in the \"type\" of the array, whicn is to the left of its dimenmsionality: `Array{TypeOfTheThings, Dimensionality}`. For `mixture` it is `Any`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays of other data structures, e.g. vectors or dictionaries, or anything, as well as multi-dimensional arrays are possible:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Array{Int64,1},1}:\n",
       " [1, 2, 3]   \n",
       " [4, 5]      \n",
       " [6, 7, 8, 9]"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_vec_num = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to make a matrix, two ways are the most common: (1) specify each entry one by one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Int64,2}:\n",
       " 1  2  3\n",
       " 4  5  6\n",
       " 7  8  9"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix = [1 2 3; # elements in same row separated by space\n",
    "          4 5 6; # semicolon means \"go to next row\"\n",
    "          7 8 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(2) you use a function that initializes a matrix. E.g. `rand(n, m)` will create an `n×m` matrix with uniformly random numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×3 Array{Float64,2}:\n",
       " 0.519171  0.160793  0.781728\n",
       " 0.655947  0.551174  0.816126\n",
       " 0.226035  0.918012  0.490806\n",
       " 0.388249  0.530115  0.455969"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = rand(4, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.16079339440758234"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R[1,2] # two dimensional indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since arrays are mutable we can change their entries, or even add new ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Int64,1}:\n",
       " 15\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci = [1, 1, 2, 3, 5, 8, 13]\n",
    "fibonacci[1] = 15\n",
    "fibonacci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8-element Array{Int64,1}:\n",
       " 15\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13\n",
       " 16"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "push!(fibonacci, 16)\n",
    "fibonacci"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The functions `push!` and `pop!` are useful with arrays, as they allow you to \"add one element the the end\" of the array or \"remove the last element\" of the array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, for multidimension arrays, the `:` symbol is useful, which means to \"select all elements in this dimension\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 0.0  0.0  0.0\n",
       " 0.0  0.0  0.0\n",
       " 0.0  0.0  0.0"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = rand(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 0.4483534700732059  \n",
       " 0.7329113520087176  \n",
       " 0.019330915228872536"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:, 1] # it means to select the first column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ranges\n",
    "Ranges are useful shorthand notations that define a \"vector\" (one dimensional array). This is done with the following syntax:\n",
    "```\n",
    "start:step:end\n",
    "range(start, end; length = ...)\n",
    "range(start, end; step = ...)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0:0.01:5.0"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = 0:0.01:5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ranges are not unique to numeric data, and can be used with anything that extends their interface, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a':1:'z'"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letterrange = 'a':'z'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As ranges are printed in this short form, to see all their elements you can use `collect`, to transform the range into a `Vector`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26-element Array{Char,1}:\n",
       " 'a'\n",
       " 'b'\n",
       " 'c'\n",
       " 'd'\n",
       " 'e'\n",
       " 'f'\n",
       " 'g'\n",
       " 'h'\n",
       " 'i'\n",
       " 'j'\n",
       " 'k'\n",
       " 'l'\n",
       " 'm'\n",
       " 'n'\n",
       " 'o'\n",
       " 'p'\n",
       " 'q'\n",
       " 'r'\n",
       " 's'\n",
       " 't'\n",
       " 'u'\n",
       " 'v'\n",
       " 'w'\n",
       " 'x'\n",
       " 'y'\n",
       " 'z'"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(letterrange)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to understand that ranges **do not store all elements in memory** like `Vector`s. Instead they produce the elements on the fly when necessary, and therefore are in general preferred over `Vector`s if the data is equi-spaced. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, ranges are typically used to index into arrays. One can type `A[1:3]` to get the first 3 elements of `A`, or `A[end-2:end]` to get the last three elements of `A`. If `A` is multidimensional, the same type of indexing can be done for any dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Array{Float64,2}:\n",
       " 0.850934   0.605064  0.350557  0.0609694\n",
       " 0.0635157  0.642909  0.289173  0.886842 \n",
       " 0.45913    0.929887  0.83624   0.93098  \n",
       " 0.418914   0.239356  0.610005  0.906587 "
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = rand(4, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 0.8509344965660368 \n",
       " 0.0635157135496649 \n",
       " 0.45912950360046945"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 0.850934   0.605064  0.350557\n",
       " 0.0635157  0.642909  0.289173\n",
       " 0.45913    0.929887  0.83624 "
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3, 1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehension\n",
    "The list comprenhension syntax `[expression(a) for a in collection if condition(a)]` is available to make a vector. The `if` part is optional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Array{Int64,1}:\n",
       "   4\n",
       "  16\n",
       "  36\n",
       "  64\n",
       " 100"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[a^2 for a in 1:10 if iseven(a)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration\n",
    "Iteration in Julia is high-level. This means that not only it has an intuitive and simple syntax, but also iteration works with anything that can be iterated. Iteration can also be extended (more on that later).\n",
    "\n",
    "\n",
    "### `for` loops\n",
    "\n",
    "A `for` loop iterates over a container and executes a piece of code, until the iteration has gone through all the elements of the container. The syntax for a `for` loop is\n",
    "\n",
    "```julia\n",
    "for *var* in *loop iterable*\n",
    "    *loop body*\n",
    "end\n",
    "```\n",
    "\n",
    "*you will notice that all Julia code-blocks end with `end`*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for n ∈ 1:5\n",
    "    println(n)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The nature of `var` depends on what the iterating container has. For example, when iterating over a dictionary one iterates over pairs of key-value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of Jenny is 867-5309\n",
      "The number of BuzzLightyear is ∞ and beyond\n",
      "The number of Ghostbusters is 555-2368\n"
     ]
    }
   ],
   "source": [
    "for (key, val) in myphonebook # pair in myphonebook\n",
    "    println(\"The number of $key is $val\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that `for pair in myphonebook` is also valid syntax. Then `pair[1]` would be the `key` and `pair[2]` would be the `val`. But Julia allows you to easily extract them on the header of the `for` loop, which also makes to code clearer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` loops\n",
    "\n",
    "A `while` loop executes a code block until a boolean condition check (that happens at the start of the block) becomes `false`. Then the loop terminates (without executing the block again). The syntax for a standard `while` loop is\n",
    "\n",
    "```julia\n",
    "while *condition*\n",
    "    *loop body*\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n < 5\n",
    "    n += 1\n",
    "    println(n)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Conditionals\n",
    "\n",
    "Conditionals execute a specific code block depending on what is the outcome of a given boolean check. Notice that as with other languages `&, |` are the boolean and and or operators.\n",
    "\n",
    "#### with `if`\n",
    "\n",
    "In Julia, the syntax\n",
    "\n",
    "```julia\n",
    "if *condition 1*\n",
    "    *option 1*\n",
    "elseif *condition 2*\n",
    "    *option 2*\n",
    "else\n",
    "    *option 3*\n",
    "end\n",
    "```\n",
    "\n",
    "evaluates the conditions sequentially and executes the code-block of the first true condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = 5, 6\n",
    "if x > y\n",
    "    x\n",
    "else\n",
    "    # all Julia code blocks by default \n",
    "    # return the last executed expression\n",
    "    y\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### with ternary operators\n",
    "\n",
    "For this last block, we could instead use the ternary operator with the syntax\n",
    "\n",
    "```julia\n",
    "a ? b : c\n",
    "```\n",
    "\n",
    "which equates to \n",
    "\n",
    "```julia\n",
    "if a\n",
    "    b\n",
    "else\n",
    "    c\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x > y ? x : y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that both the boolean conditions, as well as the conditional code blocks, can be nested and chained to arbitrary degree. E.g. this is normal syntax:\n",
    "\n",
    "```julia\n",
    "y > w ? 13 : z < x/2 ? 14 : 15\n",
    "```\n",
    "\n",
    "which is made more readable with using `()`:\n",
    "```julia\n",
    "y > w ? 13 : (z < x/2 ? 14 : 15)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `break` and `continue`\n",
    "The keywords `continue` and `break` are often used with conditionals to skip an iteration or completely stop the iteration code block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "N = 1:100\n",
    "for n in N\n",
    "    isodd(n) && continue\n",
    "    println(n)\n",
    "    n > 10 && break\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "Functions are the bread and butter of Julia, which heavily supports functional programming.\n",
    "Functions are objects by themselves and can be used as any other Julia value.\n",
    "\n",
    "Functions are declared with two ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function f(x)\n",
    "    x^2      # all Julia code blocks by default \n",
    "             # return the last executed expression\n",
    "end\n",
    "\n",
    "f(x) = x^2  # equivalent with above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And called using their name and parenthesis `()` enclosing the calling arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions in Julia support optional positional arguments, as well as keyword arguments. The **positional** arguments are **always given by their order**, while **keyword** arguments are **always given by their keyword**. Keyword arguments are all the arguments defined in a function after the symbol `;`. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "g (generic function with 2 methods)"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function g(x, y = 5; z = 2)\n",
    "    x*z*y\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(5) # give x. default y, z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(5, 3) # give x, y. default z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "75"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(5; z = 3) # give x, z. default y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(2, 4; z = 1.5) # give everything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching g(::Int64, ::Int64, ::Int64)\nClosest candidates are:\n  g(::Any, ::Any; z) at In[139]:2\n  g(::Any) at In[139]:2",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching g(::Int64, ::Int64, ::Int64)\nClosest candidates are:\n  g(::Any, ::Any; z) at In[139]:2\n  g(::Any) at In[139]:2",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[144]:1"
     ]
    }
   ],
   "source": [
    "g(2, 4, 2) # keyword arguments can't be specified by position"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Duck-typing\n",
    "Julia supports the \"duck typing\" approach. Simply put, functions work on whatever input makes sense given their operations. This can be restricted if need be. \n",
    "\n",
    "In our example with `g`, anything that supports the function `*` will work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 0.961034  0.491261  0.474666\n",
       " 0.538627  0.951596  0.312862\n",
       " 0.283563  0.117156  0.665408"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = rand(3, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 9.61034  4.91261  4.74666\n",
       " 5.38627  9.51596  3.12862\n",
       " 2.83563  1.17156  6.65408"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 2.06979   1.70533   1.55523 \n",
       " 1.94127   1.78728   1.41542 \n",
       " 0.855056  0.642338  0.760294"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(A, A; z = A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"stringstringstring\""
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(\"string\", \"string\"; z = \"string\") # * is string concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching *(::String, ::Int64)\nClosest candidates are:\n  *(::Any, ::Any, !Matched::Any, !Matched::Any...) at operators.jl:529\n  *(!Matched::Complex{Bool}, ::Real) at complex.jl:305\n  *(!Matched::Missing, ::Number) at missing.jl:115\n  ...",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching *(::String, ::Int64)\nClosest candidates are:\n  *(::Any, ::Any, !Matched::Any, !Matched::Any...) at operators.jl:529\n  *(!Matched::Complex{Bool}, ::Real) at complex.jl:305\n  *(!Matched::Missing, ::Number) at missing.jl:115\n  ...",
      "",
      "Stacktrace:",
      " [1] *(::String, ::Int64, ::Int64) at .\\operators.jl:529",
      " [2] #g#14(::Int64, ::typeof(g), ::String, ::Int64) at .\\In[139]:2",
      " [3] g(::String, ::Int64) at .\\In[139]:2",
      " [4] top-level scope at In[149]:1"
     ]
    }
   ],
   "source": [
    "g(\"string\", 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we got an error because the operation `String*Number` is not supported by default in Julia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Passing by reference: mutating vs. non-mutating functions\n",
    "\n",
    "Mutable entities in Julia are passed by reference if possible. What does this mean? Well, you can divide Julia variables into two categories: **mutable** and **immutable**. Mutable means that the values of your data can be changed in-place, i.e. literally in the place in memory the variable is stored in the computer. Immutable data cannot be changed after creation, and thus the only way to change part of immutable data is to actually make a brand new immutable object from scratch. Use `isimmutable(v)` to check if value `v` is immutable or not.\n",
    "\n",
    "For example, `Vector`s are mutable in Julia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 6\n",
       " 5\n",
       " 5"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [5, 5, 5]\n",
    "x[1] = 6 # change first entry of x\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But e.g. `Tuple`s are immutable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching setindex!(::Tuple{Int64,Int64,Int64}, ::Int64, ::Int64)",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching setindex!(::Tuple{Int64,Int64,Int64}, ::Int64, ::Int64)",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[151]:2"
     ]
    }
   ],
   "source": [
    "x = (5, 5, 5)\n",
    "x[1] = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 5, 5)"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (6, 5, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia **passes values by reference**. This means that if a mutable object is given to a function, and this object is mutated inside the function, the final result is kept at the passed object. E.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 8\n",
       " 5\n",
       " 5"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function add3!(x)\n",
    "    x[1] += 3\n",
    "    return x\n",
    "end\n",
    "\n",
    "x = [5, 5, 5]\n",
    "add3!(x)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**By convention**, functions with name ending in `!` alter their (mutable) arguments and functions lacking `!` do not. Typically the first argument of a function that ends in `!` is mutated.\n",
    "\n",
    "For example, let's look at the difference between `sort` and `sort!`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 3\n",
       " 5\n",
       " 2"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = [3, 5, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 2\n",
       " 3\n",
       " 5"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 3\n",
       " 5\n",
       " 2"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sort(v)` returns a sorted array that contains the same elements as `v`, but `v` is left unchanged. <br><br>\n",
    "\n",
    "On the other hand, when we run `sort!(v)`, the contents of v are sorted within the array `v`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 2\n",
       " 3\n",
       " 5"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort!(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 2\n",
       " 3\n",
       " 5"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The help system\n",
    "\n",
    "Typing `?` followed by a function (or type) name will display its documentation string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1my\u001b[22m\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1me\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mf\u001b[22m \u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1my\u001b[22m\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1me\u001b[22mj\u001b[0m\u001b[1mo\u001b[22min \u001b[0m\u001b[1mT\u001b[22m\u001b[0m\u001b[1my\u001b[22m\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1me\u001b[22mErr\u001b[0m\u001b[1mo\u001b[22mr\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "typeof(x)\n",
       "\\end{verbatim}\n",
       "Get the concrete type of \\texttt{x}.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> a = 1//2;\n",
       "\n",
       "julia> typeof(a)\n",
       "Rational{Int64}\n",
       "\n",
       "julia> M = [1 2; 3.5 4];\n",
       "\n",
       "julia> typeof(M)\n",
       "Array{Float64,2}\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "```\n",
       "typeof(x)\n",
       "```\n",
       "\n",
       "Get the concrete type of `x`.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> a = 1//2;\n",
       "\n",
       "julia> typeof(a)\n",
       "Rational{Int64}\n",
       "\n",
       "julia> M = [1 2; 3.5 4];\n",
       "\n",
       "julia> typeof(M)\n",
       "Array{Float64,2}\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  typeof(x)\u001b[39m\n",
       "\n",
       "  Get the concrete type of \u001b[36mx\u001b[39m.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> a = 1//2;\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> typeof(a)\u001b[39m\n",
       "\u001b[36m  Rational{Int64}\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> M = [1 2; 3.5 4];\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> typeof(M)\u001b[39m\n",
       "\u001b[36m  Array{Float64,2}\u001b[39m"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?typeof"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "Julia compiles efficient machine code that is typically fast. This means that you don't have to vectorize your code; standard `for` loops are fast (sometimes *faster* than vectorized code).\n",
    "\n",
    "However the need often arises to apply some operations across multiple arguments element-wise. This is called **broadcasting**.\n",
    "\n",
    "In Julia broadcasting is possible for any function, basic or user-defined. It is done via the simple syntax of adding a dot `.` before the parenthesis in the function call: `g.(x)`. \n",
    "\n",
    "Let's recall the previously defined `g`, now without keywords (broadcasting does not work on keywords)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h (generic function with 3 methods)"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function h(x, y = 5, z = 2)\n",
    "    x*y*z \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now apply it to a vector `x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 3"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 10\n",
       " 20\n",
       " 30"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now use vectors for both `y` and `z`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0.7321279607297009, 0.16019869547209464, 0.17526765364307928], [0.805078409756115, 0.7168818688595757, 0.8310643379601241])"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y, z = rand(3), rand(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 0.589420414362255  \n",
       " 0.22968708039780253\n",
       " 0.4369760896221301 "
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same works even with matrices, or any other iterable. Julia will try to automatically deduce what is broadcastable and what should be the size of the output. E.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Int64,2}:\n",
       " 3  3  3\n",
       " 3  3  3\n",
       " 3  3  3"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = fill(3, (3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1:3, 0:2)"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y, z = 1:3, 0:2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Int64,2}:\n",
       "  0   0   0\n",
       "  6   6   6\n",
       " 18  18  18"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If one wants to make an exponential range, they just use broadcasting, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Float64,1}:\n",
       "    0.001\n",
       "    0.01 \n",
       "    0.1  \n",
       "    1.0  \n",
       "   10.0  \n",
       "  100.0  \n",
       " 1000.0  "
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = 10.0 .^ (-3:3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*(notice that for infix operators (like `+, -`) the `.` is put before the operator)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Performance\n",
    "\n",
    "Julia matches the performance of C/Fortran not because of better hardware or better compilers than Python has, but because of design. Julia is interactive like Python, but it is not an interpreted language, it is a **compiled** one. This means that **every function call in Julia first gets compiled, based on the exact input types**. Then it is executed.\n",
    "\n",
    "*(this compilation only happens once for each unique combination of input types)*\n",
    "\n",
    "Earlier we mentioned that everything in Julia has a `Type` associated with it. When the compiler compiles a function, these types of every variable can be tracked throughout the function and all datastructures are mapped uniquely and deterministically all the way from input to output. This allows the compiler to make all the optimizations that e.g. the compilation of a C language code would do. And this (in a nutshell) is what results in the same performance as C/Fortran."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type stability\n",
    "\n",
    "This tracking of types mentioned above only works if **the type of every variable remains the same type throughout the function's operations**. Notice the distinction: the _type_ (i.e. all floating point variables remain floats) is constant, but of course the _value_ could change (i.e. going from `515134.515` to `123415.242` is fine).\n",
    "\n",
    "What if this doesn't happen? Then we have the case of **Type instability**, which is what makes beginner's code slow in 99% of the cases. \n",
    "\n",
    "Let's look at the following illustrative scenario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function unstable()\n",
    "    x = 1\n",
    "    for i = 1:10\n",
    "        x /= rand()\n",
    "    end\n",
    "    return x\n",
    "end\n",
    "\n",
    "function stable()\n",
    "    x = 1.0\n",
    "    for i = 1:10\n",
    "        x /= rand()\n",
    "    end\n",
    "    return x\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we run the code we can put things into context, by asking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Float64, Int64, Float64)"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(typeof(1.0), typeof(1), typeof(1/rand()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  132.244 ns (0 allocations: 0 bytes)\n",
      "  131.001 ns (0 allocations: 0 bytes)\n"
     ]
    }
   ],
   "source": [
    "using BenchmarkTools # Julia package for advanced (and more accurate) benchmarking\n",
    "@btime unstable();\n",
    "@btime stable();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason the `stable` version is faster than the `unstable` is because the type of `x` throughtout the function is not constant. It goes from `Int` at its definition `x = 1` to a `Float64` in the operation `x = x / rand()`, since by definition in Julia `Int / Float64` gives `Float64`.\n",
    "\n",
    "*Quick notice: this type instability problem becomes much, much worse if the instability happens in more than one variable, if the instability happens with more than 2 types, or if the types involved in the instability are much more complicated.*\n",
    "\n",
    "### Scopes\n",
    "\n",
    "In general Julia has two scopes: global scope (the one we use here, in this notebook) and local scope. Local scope is introduced by most code blocks, e.g. functions, `for` or `while` loops but *not* from conditional code blocks (`if`). The details of the scopes are mostly relevant for package development and can be found in the [Julia manual](https://docs.julialang.org/en/latest/manual/variables-and-scoping/). \n",
    "\n",
    "What is important for us is that by definition, **everything in global scope is type-unstable** and thus not performant. This happens because Julia is not a statically typed language, but a dynamically typed one. Therefore one can do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"string\""
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "x = \"string\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which is not possible in e.g. C.\n",
    "\n",
    "The performance that global scope has in code is truly massive:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  348.900 μs (7980 allocations: 140.33 KiB)\n",
      "  2.389 μs (1 allocation: 16 bytes)\n"
     ]
    }
   ],
   "source": [
    "x, y = rand(1000), rand(1000)\n",
    "a = 0.0\n",
    "@btime for i in 1:length(x)\n",
    "    global a += x[i]^2 + y[i]^2\n",
    "end\n",
    "\n",
    "function localf(x, y)\n",
    "    a = zero(eltype(x))\n",
    "    for i in 1:length(x)\n",
    "        a += x[i]^2 + y[i]^2\n",
    "    end\n",
    "    return a\n",
    "end\n",
    "\n",
    "@btime localf(x, y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusions so far\n",
    "\n",
    "1. **Put all performance critical parts of your code inside a function** to avoid global scope\n",
    "2. **Ensure that your functions are type-stable**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Allocation\n",
    "\n",
    "Another thing that is important for performance is allocation. What must be understood is that when one writes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Array{Float64,2}:\n",
       " 0.278753  0.0102621\n",
       " 0.434472  0.360526 "
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = rand(2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this *allocates* some part of your memory to store this **mutable** container that `x` represents. Creating mutable things always allocates memory. In general when you are creating something mutable you always pay two costs:\n",
    "\n",
    "1. the cost to actually calculate the numbers that go into this thing (here e.g. the cost of calling `rand()`)\n",
    "2. the cost to allocate some memory to store 1000 numbers of type `Float64`.\n",
    "\n",
    "In general you should try to avoid allocations, by more clever design of your algorithms and pre-allocating as much as possible, as is instructed by this section of [Julia's performance tips](https://docs.julialang.org/en/latest/manual/performance-tips/#Pre-allocating-outputs-1).\n",
    "\n",
    "### Example: using `mul!` for matrix multiplication\n",
    "\n",
    "If `A, B` are two square matrices (of same size), then `A*B` will make a *new* matrix. However, the function `mul!(C, A, B)` will not make a new one and instead write the result in-place in `C`. Here is an example that demonstrates how important avoiding allocations really is for performance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "randmul! (generic function with 1 method)"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using LinearAlgebra\n",
    "\n",
    "function randmul(n)\n",
    "    A = fill(rand(), n, n); B = fill(rand(), n, n)\n",
    "    return sum(A*B)\n",
    "end\n",
    "\n",
    "function randmul!(C, A, B)\n",
    "    fill!(A, rand()); fill!(B, rand())\n",
    "    mul!(C, A, B)\n",
    "    return sum(C)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(153557.6216648124, 97082.35053029115)"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 100;\n",
    "A = fill(rand(), n, n)\n",
    "B = copy(A); C = copy(A);\n",
    "\n",
    "(randmul(n), randmul!(C, A, B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  111.600 μs (6 allocations: 234.61 KiB)\n",
      "  107.000 μs (0 allocations: 0 bytes)\n"
     ]
    }
   ],
   "source": [
    "using BenchmarkTools \n",
    "@btime randmul($n);\n",
    "@btime randmul!($C, $A, $B);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, in the real world this situation becomes much worse, because the data structures are initialized more often and/or are larger and/or more complicated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusions so far\n",
    "\n",
    "1. **Try to create as little new large mutable entities in your function as possible**, to avoid memory allocations.\n",
    "2. **Pre-allocate the large and central containers of your function**, and pass them into subsequent operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises\n",
    "## Collatz conjecture\n",
    "Given a positive integer, create a function that counts the steps it takes to reach `1` following the [Collatz conjecture algorithm](https://en.wikipedia.org/wiki/Collatz_conjecture) (if $n$ is odd do $n=3n+1$ otherwise do $n=n/2$). Test it with the number 100 to get 25.\n",
    "\n",
    "*Hint: make a type-stable function by using `÷`, (`\\div<TAB>`): In Julia `/` is the floating point devision operator and thus `n/m` is always a float number even if `n, m` are integers.*\n",
    "\n",
    "## Fibonacci numbers\n",
    "Using recursion (a function that calls itself) create a function that given `n` it returns the `n`-th [Fibonacci number](https://en.wikipedia.org/wiki/Fibonacci_number). Apply it using broadcast to `1:8` to get the result `[1,1,2,3,5,8,13]`.\n",
    "\n",
    "## Logistic map\n",
    "Create a function that given `r, x0, N` it creates an orbit of length `N` of the logistic map $x_{n+1} = f(x) = rx(1-x)$. This map produces an orbit iteratively, i.e. starting from `x0` one applies `f(x0)` to get `x1`, and then applies `f(x1)` to get `x2`, and so on. \n",
    "\n",
    "*Hint: use `zeros` or `fill` to initialize a vector, instead of starting with an empty one and using `push!`*.\n",
    "\n",
    "## Counting nucleotides\n",
    "Create a function that given a DNA strand (as a `String`, e.g. `\"AGAGAGATCCCTTA\"`) it counts how much of each nucleotide (A G T or C) is present in the strand. The function should throw an error (using `error`) if an invalid nucleotide is encountered. Test your result with `\"ATATATAGGCCAX\"` and `\"ATATATAGGCCAA\"`.\n",
    "\n",
    "*Hint: there are two ways to solve this one: either making a dictionary and using `haskey` or using `count` in combination with `occursin`.*\n",
    "\n",
    "## Hamming distance\n",
    "Create a function that calculates the Hamming distance of two equal DNA strands, given as strings. This distance is defind by counting (sequentially) the number of non-equal letters in the two strands, e.g. `\"ATA\"` and `\"ATC\"` have distance of 1, while `\"ATC\"` and `\"CAT\"` have distance of 3. \n",
    "\n",
    "*Hint: this exercise has a one-liner solution, using the `zip` and `count` functions.*\n",
    "\n",
    "## Babylonian square root\n",
    "Babylonians knew how to calculate square roots several millenia ago. To get the square root of $y$ they used the algorithm $x_{n+1} = \\frac{1}{2}(x_n + \\frac{y}{x_n})$ iteratively starting from some value $x_0$ to converge to $x_n \\to \\sqrt{y}$ as $n\\to \\infty$. Implement this algortihm in a function `babylonian(y, ε)` that takes some convergence tolerance `ε`. The function should print the amount of steps it took, as well as the square root value."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.3.1",
   "language": "julia",
   "name": "julia-1.3"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.3.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}