julia_quickstart.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Julia quickstart\n",
    "\n",
    "We provide an overview of basic Julia functionality. The source code for this document is available on [GitHub](https://github.com/eomii/JuliaQuickstart). Some notable concepts not covered in this guide include the [type system](https://docs.julialang.org/en/v1/manual/types/), [variable scopes](https://docs.julialang.org/en/v1/manual/variables-and-scoping/), [array broadcasting](https://docs.julialang.org/en/v1/manual/arrays/#Broadcasting), [module imports](https://docs.julialang.org/en/v1/manual/modules/), and [exception handling](https://docs.julialang.org/en/v1/manual/control-flow/#Exception-Handling).\n",
    "\n",
    "## Printing output\n",
    "\n",
    "Use `print` to print a canonical text representation of your input. You will often want to use `println`, which appends a newline `\\n` to your output.\n",
    "\n",
    "> Note: This document contains some mathematical symbols, such as `∈`. We can write these symbols in Julia-enabled editors and the Julia REPL by entering their $\\LaTeX$ representation followed by a tab. E.g. `A ∩ B = ∅` was input as `A \\cap-tab B = \\emptyset-tab`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello, World!\n",
      "The above line printed the newline automatically.\n",
      "A and B are disjunct if A ∩ B = ∅.\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\\n\")\n",
    "println(\"Hello, World!\")\n",
    "println(\"The above line printed the newline automatically.\")\n",
    "println(\"A and B are disjunct if A ∩ B = ∅.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments\n",
    "\n",
    "Use `#` for an inline comment. Use `#=` and `=#` for multiline comments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a comment.\n",
    "\n",
    "#=\n",
    "This is\n",
    "a multiline comment\n",
    "=#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "Strings are denoted via single quotes `\"` or triple quotes `\"\"\"`, which differ in indentation behavior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a string.\n",
      "This is\n",
      "    an indented string.\n",
      "This is another string.\n",
      "This is\n",
      "another indented string.\n"
     ]
    }
   ],
   "source": [
    "println(\"This is a string.\")\n",
    "println(\"This is\n",
    "    an indented string.\")\n",
    "println(\"\"\"This is another string.\"\"\")\n",
    "println(\"\"\"This is\n",
    "    another indented string.\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contrary to many other languages, Julia uses `*` instead of `+` for string concatenation. The number of characters in a string `S` is retrievable via `length(S)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a concatenated string.\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "println(\"This is \" * \"a \" * \"concatenated string.\")\n",
    "println(length(\"1 2 ∅ c\"))  # Spaces are characters, too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers\n",
    "\n",
    "Below is the type tree of the subtypes of `Number`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number\n",
      "\tComplex\n",
      "\tReal\n",
      "\t\tAbstractFloat\n",
      "\t\t\tBigFloat\n",
      "\t\t\tFloat16\n",
      "\t\t\tFloat32\n",
      "\t\t\tFloat64\n",
      "\t\tAbstractIrrational\n",
      "\t\t\tIrrational\n",
      "\t\tInteger\n",
      "\t\t\tBool\n",
      "\t\t\tSigned\n",
      "\t\t\t\tBigInt\n",
      "\t\t\t\tInt128\n",
      "\t\t\t\tInt16\n",
      "\t\t\t\tInt32\n",
      "\t\t\t\tInt64\n",
      "\t\t\t\tInt8\n",
      "\t\t\tUnsigned\n",
      "\t\t\t\tUInt128\n",
      "\t\t\t\tUInt16\n",
      "\t\t\t\tUInt32\n",
      "\t\t\t\tUInt64\n",
      "\t\t\t\tUInt8\n",
      "\t\tRational\n"
     ]
    }
   ],
   "source": [
    "\"Print the type tree of a Type.\"\n",
    "function typetree(T::Type, indent=0::Int64)::Nothing\n",
    "    println(\"\\t\" ^ indent, T)\n",
    "    for t in subtypes(T)\n",
    "        typetree(t, indent+1)\n",
    "    end\n",
    "end\n",
    "typetree(Number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia will use types `Int64` and `Float64` for default numerical inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Int64\n",
      "Float64\n",
      "Float64\n"
     ]
    }
   ],
   "source": [
    "println(typeof(2))\n",
    "println(typeof(2.))\n",
    "println(typeof(2.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Standard binary operators will convert input and output types in the way you would expect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition:\t a + b = 5\n",
      "Multiplication:\t a * b = 6\n",
      "Subtraction:\t a - b = 1\n",
      "Division:\t a / b = 1.5\n",
      "Exponentiation:\t a ^ b = 9\n",
      "Modulo op: \t a % b = 1\n",
      "Comparison: \t a < b = false\n",
      "Comparison: \t a > b = true\n",
      "Comparison: \t a <= b = false\n",
      "Comparison: \t a >= b = true\n",
      "Comparison: \t a == b = false\n",
      "Comparison: \t a != b = true\n"
     ]
    }
   ],
   "source": [
    "a, b = 3, 2\n",
    "println(\"Addition:\\t a + b = \", a + b)\n",
    "println(\"Multiplication:\\t a * b = \", a * b)\n",
    "println(\"Subtraction:\\t a - b = \", a - b)\n",
    "println(\"Division:\\t a / b = \", a / b)\n",
    "println(\"Exponentiation:\\t a ^ b = \", a ^ b)\n",
    "println(\"Modulo op: \\t a % b = \", a % b)\n",
    "println(\"Comparison: \\t a < b = \", a < b)\n",
    "println(\"Comparison: \\t a > b = \", a > b)\n",
    "println(\"Comparison: \\t a <= b = \", a <= b)\n",
    "println(\"Comparison: \\t a >= b = \", a >= b)\n",
    "println(\"Comparison: \\t a == b = \", a == b)\n",
    "println(\"Comparison: \\t a != b = \", a != b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "We have a rather high degree of freedom for variable names. We can assign values to a variable via `=`. We refer to the [official documentation](https://docs.julialang.org/en/v1/manual/variables/#Allowed-Variable-Names) for a specification of allowed variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Hello\n",
      "1.0\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "こんにちは = \"Hello\"\n",
    "δ = 1.0\n",
    "α̂₂ = 5\n",
    "println(x)\n",
    "println(こんにちは)\n",
    "println(δ)\n",
    "println(α̂₂)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We may insert variable values in a template-like manner into strings via `$( )`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "こんにちは is a greeting.\n"
     ]
    }
   ],
   "source": [
    "greeting = \"こんにちは\"\n",
    "println(\"$(greeting) is a greeting.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control flow\n",
    "\n",
    "Generally, control structures end with an `end` keyword. Below are some examples for if-else statements. We may use the `elseif` keyword to abbreviate `else (if ... end)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old enough to drink beer.\n"
     ]
    }
   ],
   "source": [
    "minimum_age = 16 \n",
    "my_age = 25\n",
    "if my_age >= minimum_age \n",
    "    println(\"Old enough to drink beer.\")  # Only in Germany.\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not allowed to drink beer.\n"
     ]
    }
   ],
   "source": [
    "my_age -= 10\n",
    "if my_age >= minimum_age \n",
    "    println(\"Old enough to drink beer.\") # Only in Germany.\n",
    "else \n",
    "    println(\"Not allowed to drink beer.\")   \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Only with parents.\n"
     ]
    }
   ],
   "source": [
    "parents_take_care_of_you_age = 14\n",
    "if my_age >= minimum_age \n",
    "    println(\"Old enough to drink beer.\")\n",
    "elseif my_age >= parents_take_care_of_you_age\n",
    "    println(\"Only with parents.\")  # Good old German beer laws.    \n",
    "else \n",
    "    println(\"Not allowed to drink beer.\")   \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While-loops use a similar syntax. We may use the `break` keyword to break out of a control structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This loop only runs once.\n"
     ]
    }
   ],
   "source": [
    "while true\n",
    "    println(\"This loop only runs once.\")\n",
    "    break\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For-loops iterate over itarable values which we will explain more thoroughly in a later section. The syntaxes `for a = A`, `for a ∈ A` and `for a in A` are equivalent. The [iteration reference documentation](https://docs.julialang.org/en/v1/manual/interfaces/#man-interface-iteration) explains how for-loops are translated to while-loops internally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 1 2 3 4 1 2 3 4 "
     ]
    }
   ],
   "source": [
    "A = 1:4  # Define a UnitRange containing values 1, 2, 3, 4.\n",
    "for a = A print(a, \" \") end\n",
    "\n",
    "for a ∈ A print(a, \" \") end\n",
    "\n",
    "for a in A print(a, \" \") end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `continue` keyword lets us skip to the next iteration of a loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 4 "
     ]
    }
   ],
   "source": [
    "A = 1:4\n",
    "for a ∈ A\n",
    "    if a == 2 continue end\n",
    "    print(a, \" \")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "We may define functions via assignment or by using the `function` keyword. When using the `function` keyword, the last statement will be the functions return value. The `return` keyword lets us return a value mid-function. The input and output types of a function can be specified via `::`. The following function definitions are all equivalent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.605551275463989\n",
      "3.605551275463989\n",
      "3.605551275463989\n",
      "3.605551275463989\n"
     ]
    }
   ],
   "source": [
    "hypotenuse(a::Number, b::Number)::Number = √(a^2 + b^2)\n",
    "println(hypotenuse(2, 3))\n",
    "\n",
    "function hypotenuse(a::Number, b::Number)::Number\n",
    "    √(a^2 + b^2)\n",
    "end\n",
    "println(hypotenuse(2, 3))\n",
    "\n",
    "function hypotenuse(a::Number, b::Number)::Number\n",
    "    return √(a^2 + b^2)\n",
    "end\n",
    "println(hypotenuse(2, 3))\n",
    "\n",
    "function hypotenuse(a::Number, b::Number)::Number\n",
    "    return √(a^2 + b^2)\n",
    "    println(\"This will never be printed.\")\n",
    "end\n",
    "println(hypotenuse(2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions will return the last executed statement. If we do not want a function to return a value we need to return `nothing`. We may use just the keyword `nothing`, just the keyword `return`, or the combination of both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "nothing\n"
     ]
    }
   ],
   "source": [
    "function printer()::Number\n",
    "    a = 4\n",
    "end\n",
    "println(printer())\n",
    "\n",
    "function printer()::Nothing\n",
    "    a = 4\n",
    "    return nothing\n",
    "end\n",
    "println(printer())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to compose funcions via the `∘` operator, where `(f ∘ g)(x) = f(g(x))`. Note that function compositions are generally noncommutative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "f(x::Number)::Number = x^2\n",
    "g(x::Number)::Number = x + 1\n",
    "\n",
    "c = f ∘ g\n",
    "d = g ∘ f\n",
    "\n",
    "println(c(3))\n",
    "println(d(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Omitting type constraints is equivalent to enforcing the `Any` type. It is a good idea to find a good balance between generality and specificity for type constraints:\n",
    "* Type constraints provide a way of intrinsic documentation which may reduce the time it takes collaborators to understand our code.\n",
    "* Overly complicated type constraints may hinder readability and increase the time it takes collaborators to understand our code.\n",
    "* Ambiguous function definitions may cause bugs. E.g. consider a function using the `*` operator which multiplies numbers and concatenates strings. If such a function is not type constrained it will not raise an error, even if we intended the function to only work with numerical inputs.\n",
    "* Very specific type constraints may force us to unnecessarily redefine the same function multiple times to cover all relevant cases.\n",
    "* Counterintuitively, in many common cases, there is no performance penalty for using less specific types, e.g. for `Integer` and `Int64`.\n",
    "* In some cases, e.g. when working with arrays, not type-constraining a function precisely enough may impact performance ([see this reference](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-abstract-container))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "multiply(a, b) = a * b  # Prone to produce bugs.\n",
    "println(multiply(1, 2))\n",
    "println(multiply(\"Hello \", \"World!\"))  # Does not raise an error :("
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We should point out that function definitions just add methods to a function object. If we define a function several times with different type constraints we will just add more methods to the function, not overwriting or only partly overwriting previous definitions. This can lead to confusing behavior when writing e.g. a Jupyter notebook where we tend to reuse variable names often."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "3.605551275463989\n",
      "# 2 methods for generic function \"hypotenuse\":\n",
      "[1] hypotenuse(a::Number, b::Number) in Main at In[16]:14\n",
      "[2] hypotenuse(a, b) in Main at In[20]:1\n"
     ]
    }
   ],
   "source": [
    "hypotenuse(a, b) = a * b\n",
    "println(hypotenuse(\"2\", \"3\"))\n",
    "println(hypotenuse(2,3))  # Since the inputs are numbers, Julia will use the definition from a previous cell.\n",
    "println(methods(hypotenuse))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Documentation\n",
    "\n",
    "Julia docstrings implement the [Markdown](https://docs.julialang.org/en/v1/stdlib/Markdown/) standard. Docstrings may be written directly above functions and types, but also above macros (which we will not cover in an introduction to Julia) and instantiated values (e.g. constants we defined). We use Julia's string syntax for docstrings. Below are examples of docstrings which adhere to the [official docstring recommendations](https://docs.julialang.org/en/v1/manual/documentation/).\n",
    "> Note: Julia provides advanced documentation functionality such as dynamically generated documentation, which is not covered in this overview."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Doubles the input Number.\"\n",
    "function double_me(x::Number)::Number\n",
    "    return 2x\n",
    "end\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "    some_complicated_function(x)\n",
    "\n",
    "Do some very complicated things with the inputs.\n",
    "\n",
    "# Examples\n",
    "```julia-repl\n",
    "julia> some_complicated_function(3)\n",
    "nothing\n",
    "\n",
    "```\n",
    "\"\"\"\n",
    "function some_complicated_function(x)\n",
    "    return nothing\n",
    "end\n",
    "\n",
    "\n",
    "\"\"\"\"\n",
    "    function_with_complicated_arguments(a::String, b::Number, c::Any)::Any\n",
    "\n",
    "Perform crazy things with questionably complicated inputs.\n",
    "\n",
    "# Arguments\n",
    "- `a::String`: the input which does the string stuff.\n",
    "- `b::Number`: the number of times we do some weird calculation.\n",
    "- `c::Any`: whatever you want it to be.\n",
    "\"\"\"\n",
    "function function_with_complicated_arguments(a::String, b::Number, c::Any)::Any\n",
    "    return nothing\n",
    "end;  # This semicolon suppresses undesired Jupyter output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays\n",
    "\n",
    "Arrays are part of the Julia standard library. Arrays are of type `Array{T, N}`, where `T` is a supertype of the smallest common type of the array's entries and `N` is the number of array dimensions. Note that we use `display` instead of `println` to pretty-print the defined arrays. Type enforced arrays of type `Array{T, 1}` may be created via the syntax `T[A, B, C, ...]`. If `T` is omitted, the array will fall back to the smallest common type of its entries which is NOT necessarily the `Any` type (contrary to the way this was handled in function definitions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Number,1}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "4-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "4-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# An array of type Array{Number, 1}\n",
    "customarray = Number[1, 2, 3, 4]\n",
    "display(customarray)\n",
    "\n",
    "# An array of type Array{Int64, 1}\n",
    "customarray2 = Int64[1, 2, 3, 4]\n",
    "display(customarray2)\n",
    "\n",
    "# We omitted T. The smallest common element type is Int64,\n",
    "# so the line below creates an array of Type Array{Int64, 1}\n",
    "customarray3 = [1, 2, 3, 4]\n",
    "display(customarray3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Any,1}:\n",
       " 1\n",
       "  \"Some string\"\n",
       " 3\n",
       " 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# In this case the smallest common type of 'String' and 'Int64' is Any,\n",
    "# so this array will be of type Array{Any, 1}.\n",
    "customarray2 = Any[1, \"Some string\", 3, 4]\n",
    "display(customarray2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Semicolons `;` and newlines concatenate entries vertically. Spaces concatenate entries horizontally. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{String,1}:\n",
       " \"This\"\n",
       " \"is\"\n",
       " \"an\"\n",
       " \"Array.\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "4-element Array{String,1}:\n",
       " \"This\"\n",
       " \"is\"\n",
       " \"another\"\n",
       " \"Array.\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1×4 Array{String,2}:\n",
       " \"A\"  \"2-\"  \"dimensional\"  \"Array.\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# An array of type Array{String, 1}.\n",
    "stringarray = String[\"This\"; \"is\"; \"an\"; \"Array.\"]\n",
    "display(stringarray)\n",
    "\n",
    "# Another array of type Array{String, 1}.\n",
    "stringarray2 = String[\"This\",\n",
    "                \"is\",\n",
    "                \"another\",\n",
    "                \"Array.\"]\n",
    "display(stringarray2)\n",
    "\n",
    "# A 2-dimensional array of strings, i.e an array of type Array{String, 2}.\n",
    "stringarray2d = String[\"A\" \"2-\" \"dimensional\" \"Array.\"]\n",
    "display(stringarray2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do not confuse commata and concatenation:\n",
    "* An array defined via `[A, B, C]` will be of type `Array{T, 1}`, where `T` is the smallest common element type of `A`, `B`, and `C` as described above.\n",
    "* The syntax `[A; B; C]` is shorthand for `vcat(A, B, C)`, i.e the entries `A`, `B`, and `C` will be concatenated along their first dimension.\n",
    "* The syntax `[A B C]` is shorthand for `hcat(A, B, C)`, i.e. the entries `A`, `B`, and `C` will be concatenated along their second dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Array{Int64,3},1}:\n",
       " [0 0; 0 0]\n",
       "\n",
       "[0 0; 0 0]\n",
       " [0 0; 0 0]\n",
       "\n",
       "[0 0; 0 0]\n",
       " [0 0; 0 0]\n",
       "\n",
       "[0 0; 0 0]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "6×2×2 Array{Int64,3}:\n",
       "[:, :, 1] =\n",
       " 0  0\n",
       " 0  0\n",
       " 0  0\n",
       " 0  0\n",
       " 0  0\n",
       " 0  0\n",
       "\n",
       "[:, :, 2] =\n",
       " 0  0\n",
       " 0  0\n",
       " 0  0\n",
       " 0  0\n",
       " 0  0\n",
       " 0  0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2×6×2 Array{Int64,3}:\n",
       "[:, :, 1] =\n",
       " 0  0  0  0  0  0\n",
       " 0  0  0  0  0  0\n",
       "\n",
       "[:, :, 2] =\n",
       " 0  0  0  0  0  0\n",
       " 0  0  0  0  0  0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create an array of type Array{Int64, 3}.\n",
    "array3d = zeros(Int64, 2, 2, 2)\n",
    "\n",
    "# T is inferred as Array{Int64, 3}, N is 1.\n",
    "display([array3d, array3d, array3d])\n",
    "\n",
    "# T is Int64, N is 3. The size of this array is (6, 2, 2).\n",
    "display(Int64[array3d; array3d; array3d])\n",
    "\n",
    "# T is Int64, N is 3. The size of this array is (2, 6, 2).\n",
    "display(Int64[array3d array3d array3d])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagining elements of type `UnitRange` as vectors similar to 1-dimensional arrays provides intuition for concatenation behaviour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{AbstractArray{Int64,1},1}:\n",
       " 1:3\n",
       " [1, 2, 3]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2-element Array{UnitRange{Int64},1}:\n",
       " 1:3\n",
       " 1:3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "6-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 1\n",
       " 2\n",
       " 3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "3×2 Array{Int64,2}:\n",
       " 1  1\n",
       " 2  2\n",
       " 3  3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "range = 1:3\n",
    "\n",
    "# Note the different inferred types for the two arrays below.\n",
    "display([range, [1; 2; 3]])\n",
    "display([range, range])\n",
    "\n",
    "# We may imagine the UnitRange as a vector.\n",
    "display(Int64[range; [1; 2; 3]])\n",
    "display(Int64[range [1; 2; 3]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia comes with a number of functions to instantiate arrays such as `zeros` for an array filled with zeros and `rand` for an array filled with entries uniformly distributed in the interval \\[0, 1\\]. We refer to the [official documentation](https://docs.julialang.org/en/v1/manual/arrays/#Construction-and-Initialization) for a comprehensive list of array instantiation functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Array{Int64,2}:\n",
       " 0  0\n",
       " 0  0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "zeroarray  = zeros(Int64, 2, 2)\n",
    "display(zeroarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing\n",
    "\n",
    "The general syntax for indexing into an n-dimensional array is `A[I_1, ..., I_n]`, where `I_i` is a supported index. Supported indices include, but are not limited to\n",
    "\n",
    "* a scalar index for a specific index in the corresponding dimension,\n",
    "* a `UnitRange` for multiple indices in the corresponding dimension,\n",
    "* a colon `:` for all indices in a corresponding dimension.\n",
    "\n",
    "See the [official documentation](https://docs.julialang.org/en/v1/manual/arrays/#man-supported-index-types) for a comprehensive overview of supported index types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Int64,2}:\n",
       " 1  2  3\n",
       " 4  5  6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2-element Array{Int64,1}:\n",
       " 1\n",
       " 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2×2 Array{Int64,2}:\n",
       " 1  3\n",
       " 4  6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = [1 2 3; 4 5 6]\n",
    "display(a)\n",
    "\n",
    "first_entry = a[1, 1]\n",
    "display(first_entry)\n",
    "\n",
    "first_column = a[:, 1]\n",
    "display(first_column)\n",
    "\n",
    "strided_slice = a[:, 1:2:3]  # The UnitRange 1:2:3 contains the elements 1, 3.\n",
    "display(strided_slice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When indexing into strings via single integer, an element of type `Character` will be returned, not an element of type `String`. However, strings are encoded via the UTF-8 encoding and integer indices refer to the corresponding underlying bytes of the encoded character. Since the UTF-8 encoding of a `Character` may consist of multiple bytes, not every integer index is necessarily a valid index into a `String`. The valid integer indices are those referring to the first byte of encoded characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "⟺\n",
      " \n",
      "A\n",
      "StringIndexError(\"Disjunct ⟺ A ∪ B = ∅\", 11)\n"
     ]
    }
   ],
   "source": [
    "some_string = \"Disjunct ⟺ A ∪ B = ∅\"\n",
    "\n",
    "println(some_string[10])  # Returns the character ⟺.\n",
    "println(some_string[13])  # Returns a the space character.\n",
    "println(some_string[14])  # Returns A.\n",
    "\n",
    "# This raises a StringIndexError since the index is invalid.\n",
    "try\n",
    "    println(some_string[11])\n",
    "catch e\n",
    "    if isa(e, StringIndexError) println(e) end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first and last *valid* index may be indexed via `begin` and `end`, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n",
      "∅\n"
     ]
    }
   ],
   "source": [
    "println(some_string[begin])  # begin is always 1.\n",
    "println(some_string[end])  # end the index referring to the first byte of the last encoded character."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using a `UnitRange` as an index into a string a new element of type `String` is returned, not a view of the original string and not a `character`, even if the `UnitRange` contains a single element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Disjunct\n",
      "D\n",
      "String\n"
     ]
    }
   ],
   "source": [
    "println(some_string[1:8])\n",
    "println(some_string[1:1])\n",
    "println(typeof(some_string[1:1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iteration\n",
    "\n",
    "We can iterate over an array with for-loops. If we want to iterate over the valid indices of an array `A`, we iterate over `eachindex(A)`. Note that arrays are stored in column-major order, so the array below is printed as `3546`, not as `3456`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3546\n",
      "1234"
     ]
    }
   ],
   "source": [
    "A = [3 4; 5 6]\n",
    "\n",
    "for a ∈ A print(a) end\n",
    "println()\n",
    "for i ∈ eachindex(A) print(i) end "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings behave similarly but iterating over a string iterates over the valid characters, not the byte indices. We illustrate this point by using the `eachindex` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Disjunct ⟺ A ∪ B = ∅\n",
      "1 2 3 4 5 6 7 8 9 10 13 14 15 16 19 20 21 22 23 24 \n",
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 "
     ]
    }
   ],
   "source": [
    "some_string = \"Disjunct ⟺ A ∪ B = ∅\"\n",
    "\n",
    "for s ∈ some_string print(s) end\n",
    "println()\n",
    "\n",
    "for i ∈ eachindex(some_string) print(i, \" \") end  # Not equivalent to 1:length(some_string)\n",
    "println()\n",
    "\n",
    "# The `length` method measures the number of characters, not the length of the encoded bytes.\n",
    "for i ∈ 1:length(some_string) print(i, \" \") end"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.5.2",
   "language": "julia",
   "name": "julia-1.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}