notebooks/tut1_introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#2c061f\"> Macro 318: Lecture 1 - 3 / Tutorial 1 </span>  \n",
    "\n",
    "<br>\n",
    "\n",
    "## <span style=\"color:#374045\"> Introduction to Programming with Julia </span>\n",
    "\n",
    "\n",
    "#### <span style=\"color:#374045\"> Lecturer: </span> <span style=\"color:#d89216\"> <br> Dawie van Lill (dvanlill@sun.ac.za) </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Welcome to 318!\n",
    "\n",
    "For this course we are going to integrate coding into our lectures. \n",
    "\n",
    "This is the first of four tutorials that accompany the lectures.\n",
    "\n",
    "These tutorials are focused on basic computational methods in macroeconomics. \n",
    "\n",
    "In this first tutorial we will explore some basic programming topics.\n",
    "\n",
    "The first tutorial is **long**, but not all the sections are needed to complete the exercises. \n",
    "\n",
    "I will indicate which sections are `optional`.\n",
    "\n",
    "Your interest in computational work will determine how much of this guide you read. \n",
    "\n",
    "> - **Very interested** -- Read the entire notebook (even if you don't understand everything)\n",
    "> - *Somewhat interested* -- Read through the notebook and scan through the `optional` sections\n",
    "> - No interest -- Only read the slides (compulsory) so that you can complete the tutorials\n",
    "\n",
    "My advice is to work on the notebook for 30 minutes at a time. \n",
    "\n",
    "Try not to let the amount of information overwhelm you. \n",
    "\n",
    "If you get stuck at some point just keep moving ahead, you can always come back. \n",
    "\n",
    "I chose the Julia programming language because it is easy to learn and also very fast! \n",
    "\n",
    "There are other excellent languages, such as Python, R and Matlab, which are useful for economists.\n",
    "\n",
    "This notebook is meant to be used as a **reference**. \n",
    "\n",
    "I am NOT expecting you to remember everything in the notebook! \n",
    "\n",
    "While this is a reference, it only covers the very basic components of the language. Some other useful references that I used in constructing these notes are \n",
    "\n",
    "- QuantEcon [notes](https://julia.quantecon.org/getting_started_julia/julia_by_example.html)\n",
    "- Paul Soderlind [notes](https://github.com/PaulSoderlind/JuliaTutorial)\n",
    "- Cameron Pfiffer [notes](https://github.com/cpfiffer/julia-bootcamp-2022/blob/main/session-1/intro.ipynb)\n",
    "- Czech Technical University [notes](https://juliateachingctu.github.io/Julia-for-Optimization-and-Learning/stable/)\n",
    "\n",
    "You can ask me for more resources if you need it. \n",
    "\n",
    "A good textbook that teaches both Julia and programming is **Think Julia**, which can be found [here](https://benlauwens.github.io/ThinkJulia.jl/latest/book.html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial outline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this course we hope to look at different themes in computational macroeconomics. \n",
    "\n",
    "Most of modern macroeconomic research involves utilising computational methods, so it is worthwhile to get comfortable with some basic programming skills. \n",
    "\n",
    "The return on this investment is quite high. \n",
    "\n",
    "If you are interested in this type of work, feel free to contact me to talk about computational economics in Honours and Masters. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some of the focus areas\n",
    "\n",
    "1. **Fundamentals of programming** (Lectures 1 - 3)\n",
    "2. Data, math and stats (Lectures 4 - 6)\n",
    "3. Optimisation and the consumer problem (Lectures 7 - 12)\n",
    "4. Solow model (Lectures 13 - 16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial workflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A problem set will be provided before each tutorial that contains two questions. \n",
    "\n",
    "You must work on these questions before the tutorial. \n",
    "\n",
    "During the live tutorial session I will be answering questions and then I will provide a third unseen question for you to work on. \n",
    "\n",
    "There will be both normal pen and pencil exercises and computer based exercises.  \n",
    "\n",
    "For the best experience with this module it is strongly advised that students go through the tutorial material before the tutorials!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the notebooks\n",
    "\n",
    "The current notes are put together in a Jupyter notebook.\n",
    "\n",
    "There are several ways to view the notebooks. You can view the notebooks statically, which means that you will not be able to run the code. \n",
    "\n",
    "If you want to do this then simply click on the `HTML` link on the `GitHub` page. \n",
    "\n",
    "If you want to work interactively with notebooks then you need to install Anaconda and Julia. \n",
    "\n",
    "[Here](https://julia.quantecon.org/getting_started_julia/getting_started.html) is a link that explains the installation process.\n",
    "\n",
    "It is preferred that you install the program on your computer. \n",
    "\n",
    "However, if you are finding it difficult to get things working you may try the other options. \n",
    "\n",
    "I will make a brief video on how to install Anaconda and link it to Julia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Topics for the tutorial\n",
    "\n",
    "Below are the broad topics for the tutorial\n",
    "\n",
    "1. Variables\n",
    "2. Data structures\n",
    "3. Control flow\n",
    "4. Functions\n",
    "5. Visualisation\n",
    "6. Type system and generic programming\n",
    "\n",
    "Most of these topics are covered in introductory undergraduate computer science courses, so if you are a CS student then you can quickly skim for the Julia syntax. \n",
    "\n",
    "If you are comfortable with a modern programming language like Python then everything here will feel somewhat familiar.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Your first code!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many great guides that provide an introduction to Julia and programming. \n",
    "\n",
    "The **QuantEcon** website is an exceptional resource that can be used to teach yourself about computational economics. \n",
    "\n",
    "We will be borrowing some of the material from their website in this section. \n",
    "\n",
    "The main difference with these notes is that they are not nearly as comprehensive and are only meant as a starting point for your journey. \n",
    "\n",
    "Before we start our discussion, let us try and run our first Julia program. \n",
    "\n",
    "For those that have done programming before, this normally entails writing a piece of code that gives us the output ``Hello World!``. \n",
    "\n",
    "In Julia this is super easy to do. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "println(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia has many useful packages. If we want to include a specific package then we can do the following,\n",
    "\n",
    "`import Pkg`\n",
    "\n",
    "`Pkg.add(\"PackageName\")`\n",
    "\n",
    "`using PackageName`\n",
    "\n",
    "We show the process with the a few packages below. \n",
    "\n",
    "> **NB**: Make sure you run these lines, otherwise you will not be able to use the packages. You need to run these lines every time you start a new session. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations you have run your first Julia code!\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Pkg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some of the packages that we are going to use in this tutorial. This will take a minute or two to install. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m registry at `C:\\Users\\Dawie\\.julia\\registries\\General`\n",
      "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n",
      "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
      "┌ Warning: The active manifest file at `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Manifest.toml` has an old format that is being maintained.\n",
      "│ To update to the new format run `Pkg.upgrade_manifest()` which will upgrade the format without re-resolving.\n",
      "└ @ Pkg.Types C:\\buildbot\\worker\\package_win64\\build\\usr\\share\\julia\\stdlib\\v1.7\\Pkg\\src\\manifest.jl:287\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Project.toml`\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Manifest.toml`\n",
      "┌ Warning: The active manifest file is an older format with no julia version entry. Dependencies may have been resolved with a different julia version.\n",
      "└ @ nothing C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Manifest.toml:0\n",
      "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Project.toml`\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Manifest.toml`\n",
      "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Project.toml`\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Manifest.toml`\n",
      "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Project.toml`\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Manifest.toml`\n",
      "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Project.toml`\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\Dawie\\Dropbox\\2022\\318-macro\\git\\Macro-318\\Manifest.toml`\n"
     ]
    }
   ],
   "source": [
    "Pkg.add(\"DataFrames\") # Package for working with data\n",
    "Pkg.add(\"GLM\") # Package for linear regression\n",
    "Pkg.add(\"LinearAlgebra\") # Package for linear algebra applications\n",
    "Pkg.add(\"Plots\") # Package for plotting\n",
    "Pkg.add(\"TypeTree\") # Package that shows type hierarchy in tree form"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `using` command lets the computer know that you are going to be using the following installed packages in your session. This is similar to `import` in Python or `library()` in R. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "┌ Info: Precompiling Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80]\n",
      "└ @ Base loading.jl:1423\n"
     ]
    }
   ],
   "source": [
    "using Base: show_supertypes\n",
    "using DataFrames\n",
    "using GLM\n",
    "using LinearAlgebra\n",
    "using Plots\n",
    "using TypeTree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now use basic functions from these packages. In the following section you will see how we use specific functions from the packages that we have installed. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables and types\n",
    "\n",
    "After having successfully written your `Hello World!` code in Julia, a natural place to continue your journey is with variables. \n",
    "\n",
    "A variable in a programming language is going to be some sort of symbol that we assign some value. \n",
    "\n",
    "Let us use a concrete example to illustrate. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2 # We assign the value of 2 to the variable x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In programming, variables are of a certain type, depending on the value or data assigned to the variable.\n",
    "\n",
    "The `type` of the `x` variable is inferred automatically and we can check what this type is going to be by using the `typeof()` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(x) # Command to find the type of the x variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the type of the variable is `Int64`. \n",
    "\n",
    "What is an `Int64`? \n",
    "\n",
    "This is an integer! \n",
    "\n",
    "Integers are just the way that the computer records whole numbers. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Type Tree (`optional`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This variable is of type `Int64`, which is actually part of the broader `Integer` type in Julia.  \n",
    "\n",
    "How do we know this? Well we need to look at the type tree. \n",
    "\n",
    "A type tree gives us information about the different types and their relation to each other. \n",
    "\n",
    "If we look at the type tree in the code below, we see that `Int64` falls within the `Integer` class. \n",
    "\n",
    "`Int64` is a **subtype** of the broader `Integer` type, as can be seen below.\n",
    "\n",
    "> **Note**: If this type information seems strange to you right now, don't worry. We will repeatedly talk about types throughout the tutorial. You can always come back and read this section again later to make sure you understand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integer\n",
      " ├─ Bool\n",
      " ├─ GeometryBasics.OffsetInteger\n",
      " ├─ Signed\n",
      " │   ├─ BigInt\n",
      " │   ├─ Int128\n",
      " │   ├─ Int16\n",
      " │   ├─ Int32\n",
      " │   ├─ Int64\n",
      " │   └─ Int8\n",
      " └─ Unsigned\n",
      "     ├─ UInt128\n",
      "     ├─ UInt16\n",
      "     ├─ UInt32\n",
      "     ├─ UInt64\n",
      "     └─ UInt8\n"
     ]
    }
   ],
   "source": [
    "print(join(tt(Integer), \"\")) # Print the subtypes of the `Integer` type. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also see the super types of the `Int64` type. \n",
    "\n",
    "All the types \"above\" `Int64` in the type hierarchy are known as **abstract** types, while `Int64` is a **concrete** type.\n",
    "\n",
    "We will talk about **abstract** and **concrete** types again in the last section. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Int64 <: Signed <: Integer <: Real <: Number <: Any"
     ]
    }
   ],
   "source": [
    "show_supertypes(Int64) # Show the super types of `Int64`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Variables and types contd. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see from above that value `2` is now bound to `x` in the computer's memory. \n",
    "\n",
    "We can now work with `x` as if it represents the value of `2`. \n",
    "\n",
    "Since an integer is a number, we can perform basic mathematical operations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = x + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we check the type of the new variable `y`, it should also return an integer. \n",
    "\n",
    "The reason for this is that an integer plus an integer always gives back an integer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can reassign the variable `x` to another value, even with another type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.1345"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3.1345"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `x` is a floating point number. \n",
    "\n",
    "What is a floating point number? \n",
    "\n",
    "This is an *approximation* to a decimal (or real) number. \n",
    "\n",
    "A real number is infinite. Since the computer cannot fit an infinite number into its memory, we have to approximate the number with something. This is where floating point numbers comes in. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variable names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally when we name variables they will start with letters and in Julia the preference is to use **snake case**. \n",
    "\n",
    "Snake case means variables are written in lower case, with underscores used if the word becomes unreadable. \n",
    "\n",
    "As an example `new_variable` instead of `NewVariable`. \n",
    "\n",
    "The latter is an example of camel case (which will be used for modules and types toward the end of the notes). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In many Julia editing environments you will be able to use math (and other types) of symbols as variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "δ = 1; # This is the lowercase delta symbol from the Greek alphabet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also some reserved words within the language that you cannot use to name a variable. Words like `if`, `begin`, and so forth. The list of reserve words is not long, so don't be overly concerned about this. If you do use a reserve word, there will most likely be an error. \n",
    "\n",
    "If you want to know more about the style that you need to use when coding, you can look at the official [style guide](https://docs.julialang.org/en/v1/manual/style-guide/#Style-Guide-1) or the Invenia [style guide](https://github.com/invenia/BlueStyle). \n",
    "\n",
    "However, I recommend only doing that after you have completed the tutorial. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have mentioned some data types in the previous discussion on variables. \n",
    "\n",
    "Here we will talk about the most important data types.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Primitive data types\n",
    "\n",
    "There are several important data types that are at the core of computing. Some of these include, \n",
    "\n",
    "- **Booleans**: true and false\n",
    "- **Integers**: -3, -2, -1, 0, 1, 2, 3, etc.\n",
    "- **Floating point numbers**: 3.14, 2.95, 1.0, etc.\n",
    "- **Strings**: \"abc\", \"cat\", \"hello there\"\n",
    "- **Characters**: 'f', 'c', 'u'\n",
    "\n",
    "We start our discussion with Booleans, these are `true` / `false` values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Bool"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once again, the `typeof()` operator tells us what data type a variable takes. \n",
    "\n",
    "In the case above we have a `Boolean` value. \n",
    "\n",
    "Now let's look at some other well known data types.\n",
    "\n",
    "Before you run the cell, make sure that you have an idea of what to expect with respect to the input type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(122)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(122.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numbers are represented as floats and integers. \n",
    "\n",
    "Floating point numbers (floats) represent the way in which computers manifest real numbers as we said before.\n",
    "\n",
    "With numbers in mind, we can treat the computer like a calculator. \n",
    "\n",
    "We can perform basic arithmetic operations. \n",
    "\n",
    "Operators perform operations. \n",
    "\n",
    "These common operators are called the **arithmetic operators**.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Expression | Name           | Description                              |\n",
    "| :--        | :--            | :--                                      |\n",
    "| `x + y`    | binary plus    | performs addition                        |\n",
    "| `x - y`    | binary minus   | performs subtraction                     |\n",
    "| `x * y`    | times          | performs multiplication                  |\n",
    "| `x / y`    | divide         | performs division                        |\n",
    "| `x ÷ y`    | integer divide | `x / y`, truncated to an integer         |\n",
    "| `x \\ y`    | inverse divide | equivalent to `y / x`                    |\n",
    "| `x ^ y`    | power          | raises `x` to the `y`th power            |\n",
    "| `x % y`    | remainder      | equivalent to `rem(x,y)`                 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some simple examples that utilise these arithmetic operators.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2; y = 10;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The semicolon `;` is used at the end of the expression to suppress the output (similar to Matlab). This mean that it won't show the result from the code that you run. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x * y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x ^ y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y / x # Note that division converts integers to floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-26"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2x - 3y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1//5"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x // y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to display both the text and result from some of the operations above, we could use the `@show` macro. \n",
    "\n",
    "Try it out by putting `@show` in front of your piece of code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2x + 3y = 34\n",
      "(22x) * y = 440\n"
     ]
    }
   ],
   "source": [
    "@show 2x + 3y;\n",
    "@show 22x * y;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other important data types are Strings and Characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "String"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(\"Hello Class!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Char"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof('h')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of the operators used on floats and integers above can also be used on strings and characters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"abc\"; y = \"def\"; # x and y now take on String values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"abcdef\""
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x * y # The `*` operator performs concatenation on Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"abcabc\""
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x ^ 2 # The `^` operator multiplies Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we see another important class of operators that we will often encounter.\n",
    "\n",
    "These are known as the **augmentation operators**. \n",
    "\n",
    "This will be especially important in the section on control flow. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x += 1 # same as x = x + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x *= 2 # same as x = x * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x /= 2 # same as x = x / 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us consider some more **operators** that are supported in Julia. \n",
    "\n",
    "We have already used some of the mathematical operators, such as multiplication and division when it came to floating point numbers. \n",
    "\n",
    "Julia has another set of common operators that work on Booleans. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "!true # This is the negation operation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = true; y = true;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x && y # This is the `and` operator. Returns true if x and y are both true, otherwise false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x || y # This is the `or` operator. Returns true if x or y is true, otherwise false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important class of operators are the **comparison operators**.\n",
    "\n",
    "These help to generate true and false values for our conditional statements that we see later in the tutorial. \n",
    "\n",
    "| Operator  | Name                     |\n",
    "| :--       | :--                      |\n",
    "| `==`      | equality                 |\n",
    "| `!=`, `≠` | inequality               |\n",
    "| `<`       | less than                |\n",
    "| `<=`, `≤` | less than or equal to    |\n",
    "| `>`       | greater than             |\n",
    "| `>=`, `≥` | greater than or equal to |\n",
    "\n",
    "Below are some examples using comparison operators. The operators always return `true` or `false`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3; y = 2; "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x < y # If x is less than y this will return true, otherwise false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x <= y # If x is less than or equal to y then this will return true, otherwise false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x != y # If x is not equal to y then this will return true, otherwise false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == y # If x is equal to y this will return true, otherwise false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type conversion (`optional`)\n",
    "\n",
    "It is possible to convert the type of one variable to another type. \n",
    "\n",
    "One could, as an example, convert a float to string, or float to integer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"1\""
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = string(x) # Convert an integer to a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = float(x) # Convert an integer to a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"1.0\""
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = string(z) # Convert a float to a string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is not possible to convert a string to an integer. \n",
    "\n",
    "So this means there are some limitations to conversion. \n",
    "\n",
    "## Exception handling (`optional`)\n",
    "\n",
    "The following bit of code uses exception handling to show us when conversion is possible or not. \n",
    "\n",
    "We will talk about this some more in the section on control flow. \n",
    "\n",
    "[Here](https://docs.julialang.org/en/v1/manual/control-flow/#Exception-Handling) is a link that goes into some more detail on the topic. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This conversion is not possible\n"
     ]
    }
   ],
   "source": [
    "try\n",
    "    x = Int(\"22\")\n",
    "    println(\"This conversion is possible\")\n",
    "    println(\"The resulting value is $x\")\n",
    "catch\n",
    "    println(\"This conversion is not possible\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This raises the question as to whether boolean variables can be converted to an integer?\n",
    "\n",
    "Write a bit of code, given what is provided above, to try and check this. \n",
    "\n",
    "Here is some code to get started. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This conversion is not possible\n"
     ]
    }
   ],
   "source": [
    "try \n",
    "    x = Int() # fill in the missing conversion here\n",
    "    println(\"This conversion is possible\")\n",
    "    println(\"The resulting value is $x\")\n",
    "catch\n",
    "    println(\"This conversion is not possible\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures\n",
    "\n",
    "There are several types of containers, such as arrays and tuples, in Julia. \n",
    "\n",
    "These containers contain data of different types. \n",
    "\n",
    "We explore some of the most commonly used containers here. \n",
    "\n",
    "Note that we have both **mutable** and **immutable** containers in Julia.\n",
    "\n",
    "Mutable means that the value within that container can be changed, whereas immutable refers to the fact that values cannot be altered. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "Let us start with one of the basic types of containers, which are referred to as tuples. \n",
    "\n",
    "These containers are immutable (we can't change the values in the container), ordered and of a fixed length. \n",
    "\n",
    "Consider the following example of a tuple,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 20, 30)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (10, 20, 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to construct a tuple we use rounded brackets `()`.\n",
    "\n",
    "We can access the first component of a tuple by using square brackets `[]`, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1] # First element of the tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can generally unpack a tuple in the following fashion, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 20, 30)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, b, c = x # With this method of unpacking we have that a = 10, b = 20, c = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Named tuples (`optional`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to provide names to each position of a named tuple. \n",
    "\n",
    "Here is an example of a named tuple. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(first = 'a', second = 100, third = (1, 2, 3))"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (first = 'a', second = 100, third = (1, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.third # This provides access to the third element in the tuple (which in this case is another tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:third] # This is equivalent to x.third"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check whether these two ways of accessing the third element in the named tuple are the same. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.third == x[:third] # The double equality sign lets us test whether these are equal. The comparison operator must evaluate to either true or false. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can merge named tuples to add new elements to the tuple. \n",
    "\n",
    "Let us say that you want to add the sentence \"Programming is awesome!\" to the named tuple, you can do it is as follows, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(fourth = \"Programming is awesome!\",)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = (fourth = \"Programming is awesome!\", ) # Note the comma at the end, if you don't have it, then this won't work. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(first = 'a', second = 100, third = (1, 2, 3), fourth = \"Programming is awesome!\")"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merge(x, y) # Merges the old named tuple with the new one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays\n",
    "\n",
    "One of the most important containers in Julia are arrays. \n",
    "\n",
    "You will use tuples and arrays quite frequently in your code.  \n",
    "\n",
    "An array is a multi-dimensional grid of values. \n",
    "\n",
    "Vectors and matrices, such as those from mathematics, are types of arrays in Julia. \n",
    "\n",
    "Let us start with the idea of a vector. \n",
    "\n",
    "A vector is a one-dimensional array. \n",
    "\n",
    "In Julia, we can create a **column** vector by surrounding a value by brackets and separating the values with commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Any}:\n",
       " 1\n",
       "  \"abc\""
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_x = [1, \"abc\"] # example of a vector (one dimensional array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A column vector is similar to a column of values that you would have in Excel, for example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector{Any} (alias for Array{Any, 1})"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(vector_x) # We can see that the type of this new variable is a vector."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with tuples, we can access the elements of the vector in the following way, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_x[1] # Gives us the first element of the column vector."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The big difference between a tuple and an array is that we can change the values of the array. \n",
    "\n",
    "Below is an example where we change the first component of the array. \n",
    "\n",
    "This means that arrays are **mutable**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"def\""
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_x[1] = \"def\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Any}:\n",
       " \"def\"\n",
       " \"abc\""
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now see that the first element of the vector has changed from `1` to `def`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the `push!()` function to add values to this vector. \n",
    "\n",
    "This function grows the size of the vector. \n",
    "\n",
    "You might notice the `!` operator after `push`. \n",
    "\n",
    "This exclamation mark doesn't do anything particularly special in Julia. \n",
    "\n",
    "It is a coding convention to let the user know that the input is going to be altered / changed. \n",
    "\n",
    "In our case it lets us know that the vector is going to be mutated. Let us illustrate.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Any}:\n",
       " \"def\"\n",
       " \"abc\"\n",
       " \"hij\""
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "push!(vector_x, \"hij\") # vector_x is mutated here. It changes from a 2 element vector to a 3 element vector. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create matrices (two dimensional arrays) in the following way,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       " 1  2  3\n",
       " 4  5  6\n",
       " 7  8  9"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix_x = [1 2 3; 4 5 6; 7 8 9] # rows separated by spaces, columns separated by semicolons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       " 1  2  3\n",
       " 4  5  6\n",
       " 7  8  9"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix_y = [1 2 3;\n",
    "            4 5 6;\n",
    "            7 8 9] # another way to write the matrix above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important object in Julia is a sequence. We can create a sequence as follows, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1:10:21"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq_x = 1:10:21 # this is a sequence that starts at 1 and ends at 21 with an increment of 10. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to collect the values of the sequence into a vector, we can use the `collect` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       "  1\n",
       " 11\n",
       " 21"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(seq_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convenience functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several convenience functions that can be applied to arrays. We can look at the length of an array by using the `length` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(vector_x) # provides information on how long the vector is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(matrix_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(vector_x) # provides information in the format of a tuple. This is more useful for multidimensional arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(matrix_x) # we can now see the size of the matrix as 3 x 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.0\n",
       " 0.0\n",
       " 0.0"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros(3) # provides a vector of zeros with length 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the default type for the zeros in the vector above is `Float64`. If we wanted we could specify these values to be integers as follows, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 0\n",
       " 0\n",
       " 0"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros(Int, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones(3) # same thing as above, but filled with ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we want to create vectors that are filled with random values. \n",
    "\n",
    "The simplest function is `rand()`, which selects random values from the uniform distribution on the interval between zero and one. \n",
    "\n",
    "This means that each value is picked with equal probability in the interval between zero and one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.5021219314167203\n",
       " 0.49466264297875195\n",
       " 0.9523594648305321"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand(3) # values chosen will lie between zero and one and are chosen with equal probability. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An alternative is to pick values according to the standard [Normal distribution](https://en.wikipedia.org/wiki/Normal_distribution), instead of the uniform distribution as above. \n",
    "\n",
    "The Normal distribution is a distribution which is symmetric around zero, with majority of values lying within three standard deviations of the mean (which is zero). \n",
    "\n",
    "This means that this random value selection tool will select values to the right and left of zero on the real line. \n",
    "\n",
    "In other words, it will select both positive and \n",
    "negative values with about 99% of values falling within three standard deviations from the mean. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       "  0.7836362925118089\n",
       "  0.3540976403205453\n",
       " -0.4906833979183321"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "randn(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember from before that we can extract value from containers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"def\""
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_x[1] # extract the first value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix_x[2, 2] # retrieve the value in the second row and second column of the matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Any}:\n",
       " \"def\"\n",
       " \"abc\""
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_x[1:2] # gets the first two values of the vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Any}:\n",
       " \"abc\"\n",
       " \"hij\""
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_x[2:end] # extracts all the values from the second to the end of the vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Any}:\n",
       " \"def\"\n",
       " \"abc\"\n",
       " \"hij\""
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_x[:, 1] # provides all the values of the first column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Vector{Any}:\n",
       " \"def\""
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_x[1, :] # provides all the values from the first row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next let's move on to a brief discussion on linear algebra. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear algebra operations (`optional`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Linear algebra is an incredibly useful branch of mathematics that I would highly recommend students invest time in. \n",
    "\n",
    "If you are interested in the more computational or statistical side of economics then you need to learn some linear algebra. \n",
    "\n",
    "For a more detailed look at linear algebra, the best place to go is the [QuantEcon website](https://julia.quantecon.org/tools_and_techniques/linear_algebra.html). \n",
    "\n",
    "The material there is a bit more advanced than we are covering for this course, but it is worthwhile working through if you are interested in doing postgraduate work in economics.  \n",
    "\n",
    "Linear algebra entails operations with matrices and vectors at its core, so let us show some basic commands. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       " 1  2  3\n",
       " 4  5  6\n",
       " 7  8  9"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q = matrix_x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start with multiplication and addition operations on arrays. \n",
    "\n",
    "One can multiply a matrix with a scalar and also add a scalar to each component of a matrix.\n",
    "\n",
    "One can also multiply matrices together when they have the same dimension. \n",
    "\n",
    "The dimension of a matrix refers to the number of rows and the number of columns of the matrix.\n",
    "\n",
    "It is also possible to multiply the transpose of a matrix with itself (or another matrix). \n",
    "\n",
    "All of these operations will have specific applicability in certain situations. I am not speaking at this stage as to why we are doing this, but simply stating the conditions under which we can perform these operations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       "  2   4   6\n",
       "  8  10  12\n",
       " 14  16  18"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * Q # multiply matrix with scalar. All elements of matrix are multiplied by 2. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching +(::Int64, ::Matrix{Int64})\nFor element-wise addition, use broadcasting with dot syntax: scalar .+ array\n\u001b[0mClosest candidates are:\n\u001b[0m  +(::Any, ::Any, \u001b[91m::Any\u001b[39m, \u001b[91m::Any...\u001b[39m) at C:\\Users\\Dawie\\.julia\\juliaup\\julia-1.7.2+0~x64\\share\\julia\\base\\operators.jl:655\n\u001b[0m  +(::T, \u001b[91m::T\u001b[39m) where T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8} at C:\\Users\\Dawie\\.julia\\juliaup\\julia-1.7.2+0~x64\\share\\julia\\base\\int.jl:87\n\u001b[0m  +(\u001b[91m::ChainRulesCore.Tangent{P}\u001b[39m, ::P) where P at C:\\Users\\Dawie\\.julia\\packages\\ChainRulesCore\\uxrij\\src\\tangent_arithmetic.jl:146\n\u001b[0m  ...",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching +(::Int64, ::Matrix{Int64})\nFor element-wise addition, use broadcasting with dot syntax: scalar .+ array\n\u001b[0mClosest candidates are:\n\u001b[0m  +(::Any, ::Any, \u001b[91m::Any\u001b[39m, \u001b[91m::Any...\u001b[39m) at C:\\Users\\Dawie\\.julia\\juliaup\\julia-1.7.2+0~x64\\share\\julia\\base\\operators.jl:655\n\u001b[0m  +(::T, \u001b[91m::T\u001b[39m) where T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8} at C:\\Users\\Dawie\\.julia\\juliaup\\julia-1.7.2+0~x64\\share\\julia\\base\\int.jl:87\n\u001b[0m  +(\u001b[91m::ChainRulesCore.Tangent{P}\u001b[39m, ::P) where P at C:\\Users\\Dawie\\.julia\\packages\\ChainRulesCore\\uxrij\\src\\tangent_arithmetic.jl:146\n\u001b[0m  ...",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[86]:1",
      " [2] eval",
      "   @ .\\boot.jl:373 [inlined]",
      " [3] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base .\\loading.jl:1196"
     ]
    }
   ],
   "source": [
    "2 + Q  # Look at the first two line of the error message below "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The error message above (`no method matching +(::Int64, ::Matrix{Int64})`) is telling us in the first line that there is no way to add an integer to a matrix. \n",
    "\n",
    "It is basically saying that the plus operator does not know what to do when the types of the inputs are an integer and matrix. \n",
    "\n",
    "This is why types play such an important role in Julia. The plus operator looks at the types to decide what action to perform. If there is no action corresponding to the input types provided then we get a `MethodError`. \n",
    "\n",
    "In order to add the value of `2` to every component of the matrix, we need to `broadcast` the value of `2` across all the matrix components. We can think about this as adding the value of `2` elementwise. \n",
    "\n",
    "The error message here even tells us that this is the way to solve the problem, \n",
    "\n",
    "On the second line of the error message we have: For element-wise addition, use broadcasting with dot syntax: scalar .+ array\n",
    "\n",
    "Broadcasting can be done in Julia using the `.` operator. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       " 3   4   5\n",
       " 6   7   8\n",
       " 9  10  11"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 .+ Q # notice the `.` in front of the plus sign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       "  30   36   42\n",
       "  66   81   96\n",
       " 102  126  150"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q*Q # matrix multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can take the transpose of a matrix in two ways with Julia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 adjoint(::Matrix{Int64}) with eltype Int64:\n",
       " 1  4  7\n",
       " 2  5  8\n",
       " 3  6  9"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q' # technically the adjoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 transpose(::Matrix{Int64}) with eltype Int64:\n",
       " 1  4  7\n",
       " 2  5  8\n",
       " 3  6  9"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transpose(Q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       " 66   78   90\n",
       " 78   93  108\n",
       " 90  108  126"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q'Q # multiplication of the transpose with the original matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will get back to linear algebra in some of the other tutorials, so keep it in the back of your mind. \n",
    "\n",
    "Linear algebra is easily one of my favourite math topics, so we will see it throughout the tutorials and lectures. \n",
    "\n",
    "If you want to know more about linear algebra in general, I recommend the Essence of Linear Algebra series by [3Blue1Brown](https://www.youtube.com/c/3blue1brown/featured) on Youtube. \n",
    "\n",
    "It is aimed at anyone with a passing interest in linear algebra and does not suppose any type of math background to enjoy.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear algebra application: OLS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the things that you covered in the econometrics section of the course was ordinary least squares. \n",
    "\n",
    "You were told that you can easily run a regression between a dependent variable $Y$ and and independent variable (or multiple variables) $X$. \n",
    "\n",
    "In Stata the command is pretty easy to do, it should be something like\n",
    "\n",
    "`regress y x`\n",
    "\n",
    "The mathematical specification for this regression is, \n",
    "\n",
    "$$Y = X\\beta + \\epsilon$$\n",
    "\n",
    "where $\\beta$ represents the OLS coefficient and $\\epsilon$ is the error term. \n",
    "\n",
    "We cannot obtain the true value for $\\beta$ from our data since we don't have access to the full population dataset. \n",
    "\n",
    "However, we can get an estimate of $\\beta$. \n",
    "\n",
    "One of the possible estimators is the least squares estimator. \n",
    "\n",
    "This is where the idea of Ordinary Least Squares enters. \n",
    "\n",
    "I am going to skip the math (you will do this in Honours), but after doing the appropriate derivation you will see that the least squares estimate of $\\beta$ turns out to be\n",
    "\n",
    "$$\\hat{\\beta} = (X'X)^{-1}X'Y$$\n",
    "\n",
    "The prime (`'`) means transpose and $(X'X)^{-1}$ indicates the inverse of $(X'X)$.\n",
    "\n",
    "You do not need to worry about how to take the inverse of a matrix, or even transposing, for now. \n",
    "\n",
    "You simply need to acknowledge that we are looking for a combination of matrix operations on the right hand side of the equation above.\n",
    "\n",
    "Let us try to code our own version of an OLS estimator using the equation above. \n",
    "\n",
    "The first thing to do is to generate some data for $X$. We start with a `100x3` matrix, which means that there are three explanatory variables in our model. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100×3 Matrix{Float64}:\n",
       " -1.44968      0.84756     -1.89066\n",
       " -0.0479879    0.438727    -1.1625\n",
       " -1.53961     -1.27271      1.54003\n",
       "  0.00515137  -1.35396     -1.56\n",
       " -2.5055       1.27101      0.822521\n",
       " -0.772297    -0.419714    -0.303335\n",
       " -0.129674    -0.574156    -0.717127\n",
       " -0.626319     0.00332629  -0.595598\n",
       " -0.545878     0.207496     0.752876\n",
       "  1.56325      0.156119     0.371368\n",
       "  0.00244428   0.997524     1.58375\n",
       "  1.23932     -0.125537    -0.778432\n",
       " -0.126197    -0.532899    -0.892788\n",
       "  ⋮                        \n",
       "  0.0598618   -0.870918    -0.350137\n",
       " -0.658944    -0.145777     0.0926881\n",
       "  0.162333     1.349        1.19898\n",
       " -1.24737     -1.54423     -0.701932\n",
       " -0.869717     2.40158     -0.75419\n",
       "  1.07497      1.83754     -0.287505\n",
       " -0.19158      1.45101      0.179005\n",
       " -0.0258062   -0.19996      0.0218675\n",
       "  0.172032    -1.37156      1.55498\n",
       " -2.85252      0.564164     0.0183091\n",
       "  0.720006     1.15944      1.82179\n",
       " -2.95617     -0.627264    -1.37806"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = randn(100, 3) # 100x3 matrix of independent variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will change the first column to a constant column containing only ones. \n",
    "\n",
    "This is done so that there is a constant term in the regression. \n",
    "\n",
    "You have spoken about the need for a constant term in the regression with Marisa. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100-element Vector{Float64}:\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " ⋮\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:, 1] = ones(size(X, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100×3 Matrix{Float64}:\n",
       " 1.0   0.84756     -1.89066\n",
       " 1.0   0.438727    -1.1625\n",
       " 1.0  -1.27271      1.54003\n",
       " 1.0  -1.35396     -1.56\n",
       " 1.0   1.27101      0.822521\n",
       " 1.0  -0.419714    -0.303335\n",
       " 1.0  -0.574156    -0.717127\n",
       " 1.0   0.00332629  -0.595598\n",
       " 1.0   0.207496     0.752876\n",
       " 1.0   0.156119     0.371368\n",
       " 1.0   0.997524     1.58375\n",
       " 1.0  -0.125537    -0.778432\n",
       " 1.0  -0.532899    -0.892788\n",
       " ⋮                 \n",
       " 1.0  -0.870918    -0.350137\n",
       " 1.0  -0.145777     0.0926881\n",
       " 1.0   1.349        1.19898\n",
       " 1.0  -1.54423     -0.701932\n",
       " 1.0   2.40158     -0.75419\n",
       " 1.0   1.83754     -0.287505\n",
       " 1.0   1.45101      0.179005\n",
       " 1.0  -0.19996      0.0218675\n",
       " 1.0  -1.37156      1.55498\n",
       " 1.0   0.564164     0.0183091\n",
       " 1.0   1.15944      1.82179\n",
       " 1.0  -0.627264    -1.37806"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X # let us see what X looks like now"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we want to define the true coefficient values and combine them in a vector. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       "  6.0\n",
       "  3.0\n",
       " -1.0"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "β = [6.0, 3.0, -1.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This then enables us to generate our $Y$ variable using the first equation from this section. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y = X*β + randn(size(X, 1));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to try and get an estimate for $\\beta$ using the OLS equations provided above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       "  6.000426369010644\n",
       "  2.8908307871411427\n",
       " -1.1029001731841748"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "β_hat = inv(X'X) * X'Y "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the estimate for $\\beta$ is relatively close to the true value. \n",
    "\n",
    "Let us now determine how close the $\\hat{Y}$ is to the data generating process $Y$. \n",
    "\n",
    "We can do this by calculating the error and then squaring the errors, which gives us the sum of squared errors. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "71.8649861006625"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y_hat = X * β_hat # predictions of Y using β_hat\n",
    "e = Y_hat - Y # difference between predicted and actual values\n",
    "sse = e'e # sum of squared errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We don't have to make things this complicated though. \n",
    "\n",
    "Julia has it's own regression packages, such as `GLM`. \n",
    "\n",
    "In order to use this package we have to put the data in a `DataFrame`. \n",
    "\n",
    "We will discuss the `DataFrame` concept more in another tutorial. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"data-frame\"><p>100 rows × 4 columns</p><table class=\"data-frame\"><thead><tr><th></th><th>Y</th><th>X1</th><th>X2</th><th>X3</th></tr><tr><th></th><th title=\"Float64\">Float64</th><th title=\"Float64\">Float64</th><th title=\"Float64\">Float64</th><th title=\"Float64\">Float64</th></tr></thead><tbody><tr><th>1</th><td>11.4506</td><td>1.0</td><td>0.84756</td><td>-1.89066</td></tr><tr><th>2</th><td>8.08731</td><td>1.0</td><td>0.438727</td><td>-1.1625</td></tr><tr><th>3</th><td>0.166796</td><td>1.0</td><td>-1.27271</td><td>1.54003</td></tr><tr><th>4</th><td>4.27651</td><td>1.0</td><td>-1.35396</td><td>-1.56</td></tr><tr><th>5</th><td>9.10008</td><td>1.0</td><td>1.27101</td><td>0.822521</td></tr><tr><th>6</th><td>5.21424</td><td>1.0</td><td>-0.419714</td><td>-0.303335</td></tr><tr><th>7</th><td>6.44664</td><td>1.0</td><td>-0.574156</td><td>-0.717127</td></tr><tr><th>8</th><td>8.83153</td><td>1.0</td><td>0.00332629</td><td>-0.595598</td></tr><tr><th>9</th><td>7.00373</td><td>1.0</td><td>0.207496</td><td>0.752876</td></tr><tr><th>10</th><td>5.58677</td><td>1.0</td><td>0.156119</td><td>0.371368</td></tr><tr><th>11</th><td>7.69978</td><td>1.0</td><td>0.997524</td><td>1.58375</td></tr><tr><th>12</th><td>5.07799</td><td>1.0</td><td>-0.125537</td><td>-0.778432</td></tr><tr><th>13</th><td>5.10216</td><td>1.0</td><td>-0.532899</td><td>-0.892788</td></tr><tr><th>14</th><td>7.66218</td><td>1.0</td><td>1.28381</td><td>1.03102</td></tr><tr><th>15</th><td>4.56132</td><td>1.0</td><td>-0.89344</td><td>-0.0999511</td></tr><tr><th>16</th><td>5.47036</td><td>1.0</td><td>-0.439062</td><td>-0.202439</td></tr><tr><th>17</th><td>0.540045</td><td>1.0</td><td>-0.827337</td><td>1.51442</td></tr><tr><th>18</th><td>2.01035</td><td>1.0</td><td>-1.31003</td><td>-1.05353</td></tr><tr><th>19</th><td>9.09764</td><td>1.0</td><td>0.072004</td><td>-2.46992</td></tr><tr><th>20</th><td>10.4114</td><td>1.0</td><td>1.30366</td><td>0.921623</td></tr><tr><th>21</th><td>8.03983</td><td>1.0</td><td>0.76075</td><td>0.127951</td></tr><tr><th>22</th><td>1.53802</td><td>1.0</td><td>-0.679566</td><td>1.87681</td></tr><tr><th>23</th><td>7.03806</td><td>1.0</td><td>0.826009</td><td>1.3208</td></tr><tr><th>24</th><td>4.13391</td><td>1.0</td><td>-0.140493</td><td>1.36548</td></tr><tr><th>25</th><td>8.98438</td><td>1.0</td><td>1.74378</td><td>1.4752</td></tr><tr><th>26</th><td>7.37072</td><td>1.0</td><td>0.143404</td><td>-0.267576</td></tr><tr><th>27</th><td>2.48951</td><td>1.0</td><td>-1.11592</td><td>-0.156229</td></tr><tr><th>28</th><td>9.36988</td><td>1.0</td><td>1.56383</td><td>0.975258</td></tr><tr><th>29</th><td>5.0817</td><td>1.0</td><td>-0.137925</td><td>1.29092</td></tr><tr><th>30</th><td>5.23863</td><td>1.0</td><td>-0.0589273</td><td>0.025542</td></tr><tr><th>&vellip;</th><td>&vellip;</td><td>&vellip;</td><td>&vellip;</td><td>&vellip;</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cccc}\n",
       "\t& Y & X1 & X2 & X3\\\\\n",
       "\t\\hline\n",
       "\t& Float64 & Float64 & Float64 & Float64\\\\\n",
       "\t\\hline\n",
       "\t1 & 11.4506 & 1.0 & 0.84756 & -1.89066 \\\\\n",
       "\t2 & 8.08731 & 1.0 & 0.438727 & -1.1625 \\\\\n",
       "\t3 & 0.166796 & 1.0 & -1.27271 & 1.54003 \\\\\n",
       "\t4 & 4.27651 & 1.0 & -1.35396 & -1.56 \\\\\n",
       "\t5 & 9.10008 & 1.0 & 1.27101 & 0.822521 \\\\\n",
       "\t6 & 5.21424 & 1.0 & -0.419714 & -0.303335 \\\\\n",
       "\t7 & 6.44664 & 1.0 & -0.574156 & -0.717127 \\\\\n",
       "\t8 & 8.83153 & 1.0 & 0.00332629 & -0.595598 \\\\\n",
       "\t9 & 7.00373 & 1.0 & 0.207496 & 0.752876 \\\\\n",
       "\t10 & 5.58677 & 1.0 & 0.156119 & 0.371368 \\\\\n",
       "\t11 & 7.69978 & 1.0 & 0.997524 & 1.58375 \\\\\n",
       "\t12 & 5.07799 & 1.0 & -0.125537 & -0.778432 \\\\\n",
       "\t13 & 5.10216 & 1.0 & -0.532899 & -0.892788 \\\\\n",
       "\t14 & 7.66218 & 1.0 & 1.28381 & 1.03102 \\\\\n",
       "\t15 & 4.56132 & 1.0 & -0.89344 & -0.0999511 \\\\\n",
       "\t16 & 5.47036 & 1.0 & -0.439062 & -0.202439 \\\\\n",
       "\t17 & 0.540045 & 1.0 & -0.827337 & 1.51442 \\\\\n",
       "\t18 & 2.01035 & 1.0 & -1.31003 & -1.05353 \\\\\n",
       "\t19 & 9.09764 & 1.0 & 0.072004 & -2.46992 \\\\\n",
       "\t20 & 10.4114 & 1.0 & 1.30366 & 0.921623 \\\\\n",
       "\t21 & 8.03983 & 1.0 & 0.76075 & 0.127951 \\\\\n",
       "\t22 & 1.53802 & 1.0 & -0.679566 & 1.87681 \\\\\n",
       "\t23 & 7.03806 & 1.0 & 0.826009 & 1.3208 \\\\\n",
       "\t24 & 4.13391 & 1.0 & -0.140493 & 1.36548 \\\\\n",
       "\t25 & 8.98438 & 1.0 & 1.74378 & 1.4752 \\\\\n",
       "\t26 & 7.37072 & 1.0 & 0.143404 & -0.267576 \\\\\n",
       "\t27 & 2.48951 & 1.0 & -1.11592 & -0.156229 \\\\\n",
       "\t28 & 9.36988 & 1.0 & 1.56383 & 0.975258 \\\\\n",
       "\t29 & 5.0817 & 1.0 & -0.137925 & 1.29092 \\\\\n",
       "\t30 & 5.23863 & 1.0 & -0.0589273 & 0.025542 \\\\\n",
       "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m100×4 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m Y         \u001b[0m\u001b[1m X1      \u001b[0m\u001b[1m X2          \u001b[0m\u001b[1m X3         \u001b[0m\n",
       "\u001b[1m     \u001b[0m│\u001b[90m Float64   \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64     \u001b[0m\u001b[90m Float64    \u001b[0m\n",
       "─────┼─────────────────────────────────────────────\n",
       "   1 │ 11.4506        1.0   0.84756     -1.89066\n",
       "   2 │  8.08731       1.0   0.438727    -1.1625\n",
       "   3 │  0.166796      1.0  -1.27271      1.54003\n",
       "   4 │  4.27651       1.0  -1.35396     -1.56\n",
       "   5 │  9.10008       1.0   1.27101      0.822521\n",
       "   6 │  5.21424       1.0  -0.419714    -0.303335\n",
       "   7 │  6.44664       1.0  -0.574156    -0.717127\n",
       "   8 │  8.83153       1.0   0.00332629  -0.595598\n",
       "   9 │  7.00373       1.0   0.207496     0.752876\n",
       "  10 │  5.58677       1.0   0.156119     0.371368\n",
       "  11 │  7.69978       1.0   0.997524     1.58375\n",
       "  ⋮  │     ⋮         ⋮          ⋮           ⋮\n",
       "  91 │  9.11794       1.0   1.349        1.19898\n",
       "  92 │  3.11471       1.0  -1.54423     -0.701932\n",
       "  93 │ 12.8018        1.0   2.40158     -0.75419\n",
       "  94 │ 11.6134        1.0   1.83754     -0.287505\n",
       "  95 │  9.96753       1.0   1.45101      0.179005\n",
       "  96 │  5.81249       1.0  -0.19996      0.0218675\n",
       "  97 │ -0.513723      1.0  -1.37156      1.55498\n",
       "  98 │  9.27233       1.0   0.564164     0.0183091\n",
       "  99 │  8.76744       1.0   1.15944      1.82179\n",
       " 100 │  4.85926       1.0  -0.627264    -1.37806\n",
       "\u001b[36m                                    79 rows omitted\u001b[0m"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = DataFrame(Y = Y, X1 = X[:, 1], X2 = X[:, 2], X3 = X[:, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, CholeskyPivoted{Float64, Matrix{Float64}}}}, Matrix{Float64}}\n",
       "\n",
       "Y ~ 1 + X1 + X2 + X3\n",
       "\n",
       "Coefficients:\n",
       "───────────────────────────────────────────────────────────────────────────\n",
       "                Coef.   Std. Error       t  Pr(>|t|)  Lower 95%   Upper 95%\n",
       "───────────────────────────────────────────────────────────────────────────\n",
       "(Intercept)   0.0      NaN          NaN       NaN     NaN        NaN\n",
       "X1            6.00043    0.0867406   69.18    <1e-83    5.82827    6.17258\n",
       "X2            2.89083    0.0878657   32.90    <1e-53    2.71644    3.06522\n",
       "X3           -1.1029     0.0864803  -12.75    <1e-21   -1.27454   -0.931261\n",
       "───────────────────────────────────────────────────────────────────────────"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lm(@formula(Y ~ X1 + X2 + X3), data) # This is similar to the command you issued in Stata. lm stands for linear model. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see the result for coefficient estimates are the same as those we achieved with our linear algebra inspired version of OLS."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One important topic that we need to think about is `broadcasting`.\n",
    "\n",
    "If you have a particular vector, such as `[1, 2, 3]`, then you might want to apply a certain operation to each of the elements in that vector. \n",
    "\n",
    "Perhaps you want to find out what the `sin` of each of those values are independently? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_vec = [1.0, 2.0, 3.0];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Julia we can simply use our dot syntax to enable this.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.8414709848078965\n",
       " 0.9092974268256817\n",
       " 0.1411200080598672"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin.(x_vec) # notice the dot operator. What happens without the dot operator?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see with this example that the `sin()` function has been applied elementwise to the components of the vector. \n",
    "\n",
    "This is true for any function that you want to broadcast. \n",
    "\n",
    "This even applies to user defined functions, which we will discuss towards the end of the tutorial.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we didn't have this broadcasting method we would have to write a loop that performs the task (we will speak about loops soon). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.8414709848078965\n",
       " 0.9092974268256817\n",
       " 0.1411200080598672"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_vec = similar(x_vec)\n",
    "for (i, x) in enumerate(x_vec)\n",
    "    y_vec[i] = sin(x)\n",
    "end\n",
    "\n",
    "y_vec # This now gives you sin of the x vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Writing a loop like this for a simple operation seems wasteful. \n",
    "\n",
    "The `dot operator` is a much better alternative. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we will be looking at conditional statements and loops. \n",
    "\n",
    "Conditional statements provide branches to a program depending on a certain condition. \n",
    "\n",
    "The most recognisable conditional statement is the `if-else` statement. \n",
    "\n",
    "Consider the example below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "if x < 2\n",
    "    print(\"first\")\n",
    "elseif x > 4\n",
    "    print(\"second\")\n",
    "elseif x < 0\n",
    "    print(\"third\")\n",
    "else\n",
    "    print(\"fourth\")\n",
    "end "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can also represent conditional statements via a ternary operator, this is often more compact. \n",
    "\n",
    "Can you make sense of what the expression below is saying? If you don't know then that is completely understandable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y, z = 1, 3, true\n",
    "z ? x : y "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In words it says, if `z` is `true` then return value of `x`, otherwise return the value of `y`. \n",
    "\n",
    "The above can also be written as follows, in a more lengthy if-else fashion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if z \n",
    "    x\n",
    "else \n",
    "    y\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A shorter, and perhaps more understandable way would be the following. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ifelse(z, x, y) # This means, return x if z is true, otherwise return y. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When writing code, avoid repeating yourself at ALL COSTS. This is the DRY (**d**o not **r**epeat **y**ourself) principle in coding. \n",
    "\n",
    "Consider the following example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 0\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [0,1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Any[]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_1 = [] # empty array (list in python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now use the `append!()` function to add values to the empty array one by one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Any}:\n",
       "  0\n",
       "  1\n",
       "  4\n",
       "  9\n",
       " 16"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "append!(y_1, x[1] ^ 2)\n",
    "append!(y_1, x[2] ^ 2)\n",
    "append!(y_1, x[3] ^ 2)\n",
    "append!(y_1, x[4] ^ 2)\n",
    "append!(y_1, x[5] ^ 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This process above works, but we have to repeat our code five times. What if the vector had 100 element?\n",
    "\n",
    "In this case it is better to write a loop to do the hard work for us. \n",
    "\n",
    "Generally we will encounter two types of loops. \n",
    "\n",
    "We get `for` loops and `while` loops. We will mostly focus on `for` loops here. \n",
    "\n",
    "They are best in cases when you know exactly how many times you want to loop. On the other hand, `while` loops are used when you want to keep looping till something in particular happens (some condition is met). \n",
    "\n",
    "Let us try and fill our array using a `for` loop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Any[]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_2 = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first start with a basic loop and then fill our array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i = 0\n",
      "i = 1\n",
      "i = 2\n",
      "i = 3\n",
      "i = 4\n"
     ]
    }
   ],
   "source": [
    "for i in x # Remember that x = [0,1,2,3,4]\n",
    "    @show i\n",
    "    i += 1 # This is the same as i = i + 1\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `@show i` portion of the code helps us keep track of how the value of `i` changes through the loop.  \n",
    "\n",
    "In the following loop the array `y_2` will be altered. \n",
    "\n",
    "We refer to `y_2` as a **global** variable. \n",
    "\n",
    "We will talk about variable scope, local and global variables, later when we get to functions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any[0]\n",
      "Any[0, 1]\n",
      "Any[0, 1, 4]\n",
      "Any[0, 1, 4, 9]\n",
      "Any[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "for i in x\n",
    "    append!(y_2, i ^ 2)\n",
    "    println(y_2)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us look at another way in which we can loop over the values from 0 to 4. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Any[]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_3 = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any[0]\n",
      "Any[0, 1]\n",
      "Any[0, 1, 4]\n",
      "Any[0, 1, 4, 9]\n",
      "Any[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "for i in 0:4\n",
    "    append!(y_3, i ^ 2)\n",
    "    println(y_3)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see here that instead of `x` we have `0:4`. \n",
    "\n",
    "The command `0:4` generates a sequence of values from zero to four: 0, 1, 2, 3, 4. \n",
    "\n",
    "**NB**: If we look at the type of `0:4` we see that this is not actually an array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UnitRange{Int64}"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(0:4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is actually a special type referred to as a `UnitRange`. \n",
    "\n",
    "If we want to make an array out of `0:4` we have to use the `collect()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector{Int64} (alias for Array{Int64, 1})"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(collect(0:4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have that this is an array. It is equivalent to the `x` array that we created initially. \n",
    "\n",
    "We can check equivalence with the `==` operator. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(0:4) == x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehension and generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way in which we can fill our array with values, without having to start with an empty array is array comprehension. \n",
    "\n",
    "This can be done as follows, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       "  0\n",
       "  1\n",
       "  4\n",
       "  9\n",
       " 16"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_4 = [i ^ 2 for i in x] # array comprehension -- we will mention this again later on"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do not have the enclosing square brackets then this produces an object known as a **generator**.\n",
    "\n",
    "The nice thing about a generator is that it does not allocate the full array in memory.\n",
    "\n",
    "You can call the output from the generator into memory with something like the `collect` function. \n",
    "\n",
    "In the following example, we first construct the generator and then call a value into memory by using the `collect` function.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Base.Generator{UnitRange{Int64}, var\"#3#4\"}(var\"#3#4\"(), 1:1000)"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen = (1/n^2 for n in 1:1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000-element Vector{Float64}:\n",
       " 1.0\n",
       " 0.25\n",
       " 0.1111111111111111\n",
       " 0.0625\n",
       " 0.04\n",
       " 0.027777777777777776\n",
       " 0.02040816326530612\n",
       " 0.015625\n",
       " 0.012345679012345678\n",
       " 0.01\n",
       " 0.008264462809917356\n",
       " 0.006944444444444444\n",
       " 0.005917159763313609\n",
       " ⋮\n",
       " 1.0223683981838647e-6\n",
       " 1.0203040506070809e-6\n",
       " 1.0182459491630528e-6\n",
       " 1.01619406867846e-6\n",
       " 1.0141483841066723e-6\n",
       " 1.012108870526985e-6\n",
       " 1.01007550314386e-6\n",
       " 1.0080482572861728e-6\n",
       " 1.0060271084064632e-6\n",
       " 1.0040120320801925e-6\n",
       " 1.002003004005006e-6\n",
       " 1.0e-6"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could have also called a value into memory using something like the `mean` or `sum` function,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6439345666815615"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could also use double (nested) `for loops`! \n",
    "\n",
    "This means that we nest a loop within another loop. \n",
    "\n",
    "This is used a lot in practice. Here is a simple example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(i, j) = (1, 1)\n",
      "(i, j) = (1, 2)\n",
      "(i, j) = (1, 3)\n",
      "(i, j) = (2, 2)\n",
      "(i, j) = (2, 3)\n",
      "(i, j) = (3, 3)\n"
     ]
    }
   ],
   "source": [
    "for i in 1:3\n",
    "    for j in i:3\n",
    "        @show (i, j)\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Julia, we can loop over ranges as above, but we can also loop over any iterable object. \n",
    "\n",
    "These iterable objects include arrays or tuples of any kind. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{String}:\n",
       " \"watch Netflix\"\n",
       " \"like 318 homework\""
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "actions = [\"watch Netflix\", \"like 318 homework\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peter doesn't watch Netflix\n",
      "Peter doesn't like 318 homework\n"
     ]
    }
   ],
   "source": [
    "for action in actions\n",
    "    println(\"Peter doesn't $action\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in 1:3\n",
    "    println(i)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1:5"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_values = 1:5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "for x in x_values\n",
    "    println(x * x)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Break and continue (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I don't think that `break` and `continue` statements are easy to read and don't often use them. I think there are easier ways to write loops. However, here is an example that uses these control flow commands.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Vector{Int64}:\n",
       " 0\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5\n",
       " 6\n",
       " 7\n",
       " 8\n",
       " 9"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_array = []\n",
    "x_array = collect(0:9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You don't have to spend too much time with this code. It is simply here to illustrate a basic point. Sometimes we will include `break` and `continue` statements within a loop that allow skipping and termination of loops at particular points. \n",
    "\n",
    "In the example below the `continue` statement states that if `i == 1` we continue the loop and then go to the next iteration. If we reach the point where `i == 4` then the  `break` command tells the computer to exit the `for` loop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any[1, 4]\n"
     ]
    }
   ],
   "source": [
    "for (i, x) in enumerate(x_array)\n",
    "    \n",
    "    if i == 1\n",
    "        continue\n",
    "    elseif i == 4\n",
    "        break\n",
    "    end\n",
    "    \n",
    "    append!(y_array, x^2)\n",
    "end\n",
    "\n",
    "println(y_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions and methods\n",
    "\n",
    "Functions are key to writing more complex code. \n",
    "\n",
    "You should always write in terms of functions if possible. \n",
    "\n",
    "From mathematics we know that a function is an abstraction that takes in some input and returns an output. \n",
    "\n",
    "In the world of computing the idea is similar. \n",
    "\n",
    "A function is an object that maps a tuple of argument values to a `return` value\n",
    "\n",
    "Let us take a look at some functions below.\n",
    "\n",
    "The most common way to write a function is the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function f(x) # function header\n",
    "    return x ^ 2 # body of the function\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function accepts one input and returns one output. Namely, it takes the value of `x` and then squares it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A shorter way to write the same function is, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "g (generic function with 1 method)"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(x) = x ^ 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could also use an anonymous function, as follows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#5 (generic function with 1 method)"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = (x) -> x ^ 2 # Lambda or anonymous function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the following function we have two inputs, `x` and `y`, that return one output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "k (generic function with 1 method)"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function k(x, y)\n",
    "    return x ^ 2 + y ^ 2\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k(2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function can also return a tuple of values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "m (generic function with 1 method)"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function m(x, y)\n",
    "    z = x ^ 2\n",
    "    q = y ^ 2\n",
    "    \n",
    "    return z, q\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can unpack this tuple as follows, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 4)"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z, q = m(2, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type annotations for functions (`optional`)\n",
    "\n",
    "I just want to squeeze in a quick word about types here before we continue. \n",
    "\n",
    "This is an optional section and has more to do with the Julia type system. \n",
    "\n",
    "It is a bit more technical, so you can skip on the first reading. \n",
    "\n",
    "Within the Julia type system, we can restrict our function to only accept a certain type of input. \n",
    "\n",
    "We covered the different primitive types such as integers and floats. \n",
    "\n",
    "In order to do this all that you need to do is add `::TypeName` after the input argument for the function. \n",
    "\n",
    "Let us showcase this with an example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fun_1 (generic function with 2 methods)"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun_1(x::Int64) = x + 2\n",
    "fun_1(x::Float64) = x * 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What you see above is that this function, `fun_1`, is a generic function with two **methods**. \n",
    "\n",
    "In the case above, the output that you receive depends on the **type** of input that you provide. \n",
    "\n",
    "This is an example of *multiple dispatch*. \n",
    "\n",
    "This is one of the unique selling points of Julia, that not many other languages have. \n",
    "\n",
    "Let us show how the return value differs based on different inputs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun_1(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fun_1(1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is `return`? (`optional`)\n",
    "\n",
    "We mentioned the return value in the previous section so let us talk about the `return` part of the function body. What does it actually represent? \n",
    "\n",
    "`return` basically instructs the program to exit the function and return the specified value. \n",
    "\n",
    "Let us look at an example of where the `return` part will prevent execution of other parts of the function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "return_example_1 (generic function with 1 method)"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function return_example_1(x)\n",
    "\n",
    "    if x > 5\n",
    "        return x + 5 # this will exit the function immediately\n",
    "\n",
    "        println(x - 9) # this will never execute, it is after the return\n",
    "    end\n",
    "\n",
    "    return x / 5 # if x <= then this will be returned\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_example_1(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_example_1(10) # notice that the `println(x - 9)` doesn't execute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You don't have to write `return` in the body of the function. In Julia the function will return the last line of the function. However, it is good coding practice to write `return` so that you can see within the function what is being returned. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "return_example_2a (generic function with 1 method)"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function return_example_2a(x)\n",
    "    y = x / 2 # this is the part that will be returned\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_example_2a(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "return_example_2b (generic function with 1 method)"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function return_example_2b(x)\n",
    "    y = x % 2 \n",
    "    x # this is now the part that will be returned\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_example_2b(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also get multiple values returned, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "return_example_2c (generic function with 1 method)"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function return_example_2c(x)\n",
    "    y = x % 2 \n",
    "    y + x, y - x, y * x, y / x # this will generate multiple return values\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, -4, 0, 0.0)"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_example_2c(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will notice that the return above has parentheses around it, which means that the values are contained in a tuple. Remember our discussion on tuples (an immutable type) from earlier.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Global variables are generally considered to be a bad idea.\n",
    "\n",
    "If you want to be a good programmer, you need to understand the basics of local scoping. \n",
    "\n",
    "Most of the code in the notebook has been contained in the global scope, but if you are writing scripts and source code you will most likely want to wrap code in functions to avoid variables entering the global scope. \n",
    "\n",
    "When you copy variables inside functions, they become local and the function is said to become a **closure**. \n",
    "\n",
    "We will show what we mean through some examples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 2 # global variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function f(x)\n",
    "    return x ^ a\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "g (generic function with 1 method)"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function g(x; a = 2)\n",
    "    return x ^ a\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "cannot define function h; it already has a value",
     "output_type": "error",
     "traceback": [
      "cannot define function h; it already has a value",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ none:0",
      " [2] top-level scope",
      "   @ In[158]:1",
      " [3] eval",
      "   @ .\\boot.jl:373 [inlined]",
      " [4] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base .\\loading.jl:1196"
     ]
    }
   ],
   "source": [
    "function h(x)\n",
    "    a = 2 # a is local \n",
    "    return x ^ a\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 4, 4)"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(2), g(2), h(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 4, 4)"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(2), g(2), h(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Never rely on global variables! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keyword arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can give function arguments default values. If an argument is not provided then the default value is used. Alternatively, we can use keyword arguments. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference between keyword and standard (positional) arguments is that they are parsed and bounded by name rather than the order in the function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "p (generic function with 1 method)"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function p(x, y; a = 2, b = 2)\n",
    "    return x ^ a + y ^ b\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the `;` in our function call. \n",
    "\n",
    "Using keyword arguments is generally discouraged, but there are times when it is useful. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p(2, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "260"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p(2, 4, b = 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p(2, 4, a = 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us show the basic principles of plotting in Julia. \n",
    "\n",
    "There is a lot to learn about visualisation in Julia, we only showcase a small portion here. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = 0:0.1:20;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "ys = sin.(xs); # we are using dot syntax - indicates broadcasting over the entire sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip480\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<path clip-path=\"url(#clip480)\" d=\"\n",
       "M0 1600 L2400 1600 L2400 0 L0 0  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip481\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<path clip-path=\"url(#clip480)\" d=\"\n",
       "M193.936 1486.45 L2352.76 1486.45 L2352.76 47.2441 L193.936 47.2441  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip482\">\n",
       "    <rect x=\"193\" y=\"47\" width=\"2160\" height=\"1440\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  255.035,1486.45 255.035,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  764.19,1486.45 764.19,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1273.35,1486.45 1273.35,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1782.5,1486.45 1782.5,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2291.66,1486.45 2291.66,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1486.45 2352.76,1486.45 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  255.035,1486.45 255.035,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  764.19,1486.45 764.19,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1273.35,1486.45 1273.35,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1782.5,1486.45 1782.5,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2291.66,1486.45 2291.66,1467.55 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip480)\" d=\"M255.035 1517.37 Q251.424 1517.37 249.595 1520.93 Q247.789 1524.47 247.789 1531.6 Q247.789 1538.71 249.595 1542.27 Q251.424 1545.82 255.035 1545.82 Q258.669 1545.82 260.474 1542.27 Q262.303 1538.71 262.303 1531.6 Q262.303 1524.47 260.474 1520.93 Q258.669 1517.37 255.035 1517.37 M255.035 1513.66 Q260.845 1513.66 263.9 1518.27 Q266.979 1522.85 266.979 1531.6 Q266.979 1540.33 263.9 1544.94 Q260.845 1549.52 255.035 1549.52 Q249.225 1549.52 246.146 1544.94 Q243.09 1540.33 243.09 1531.6 Q243.09 1522.85 246.146 1518.27 Q249.225 1513.66 255.035 1513.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M754.468 1514.29 L772.825 1514.29 L772.825 1518.22 L758.751 1518.22 L758.751 1526.7 Q759.769 1526.35 760.788 1526.19 Q761.806 1526 762.825 1526 Q768.612 1526 771.991 1529.17 Q775.371 1532.34 775.371 1537.76 Q775.371 1543.34 771.899 1546.44 Q768.426 1549.52 762.107 1549.52 Q759.931 1549.52 757.663 1549.15 Q755.417 1548.78 753.01 1548.04 L753.01 1543.34 Q755.093 1544.47 757.315 1545.03 Q759.538 1545.58 762.014 1545.58 Q766.019 1545.58 768.357 1543.48 Q770.695 1541.37 770.695 1537.76 Q770.695 1534.15 768.357 1532.04 Q766.019 1529.94 762.014 1529.94 Q760.139 1529.94 758.264 1530.35 Q756.413 1530.77 754.468 1531.65 L754.468 1514.29 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M1248.03 1544.91 L1255.67 1544.91 L1255.67 1518.55 L1247.36 1520.21 L1247.36 1515.95 L1255.63 1514.29 L1260.3 1514.29 L1260.3 1544.91 L1267.94 1544.91 L1267.94 1548.85 L1248.03 1548.85 L1248.03 1544.91 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M1287.39 1517.37 Q1283.77 1517.37 1281.95 1520.93 Q1280.14 1524.47 1280.14 1531.6 Q1280.14 1538.71 1281.95 1542.27 Q1283.77 1545.82 1287.39 1545.82 Q1291.02 1545.82 1292.83 1542.27 Q1294.65 1538.71 1294.65 1531.6 Q1294.65 1524.47 1292.83 1520.93 Q1291.02 1517.37 1287.39 1517.37 M1287.39 1513.66 Q1293.2 1513.66 1296.25 1518.27 Q1299.33 1522.85 1299.33 1531.6 Q1299.33 1540.33 1296.25 1544.94 Q1293.2 1549.52 1287.39 1549.52 Q1281.58 1549.52 1278.5 1544.94 Q1275.44 1540.33 1275.44 1531.6 Q1275.44 1522.85 1278.5 1518.27 Q1281.58 1513.66 1287.39 1513.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M1757.69 1544.91 L1765.33 1544.91 L1765.33 1518.55 L1757.02 1520.21 L1757.02 1515.95 L1765.28 1514.29 L1769.96 1514.29 L1769.96 1544.91 L1777.59 1544.91 L1777.59 1548.85 L1757.69 1548.85 L1757.69 1544.91 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M1787.08 1514.29 L1805.44 1514.29 L1805.44 1518.22 L1791.37 1518.22 L1791.37 1526.7 Q1792.39 1526.35 1793.4 1526.19 Q1794.42 1526 1795.44 1526 Q1801.23 1526 1804.61 1529.17 Q1807.99 1532.34 1807.99 1537.76 Q1807.99 1543.34 1804.52 1546.44 Q1801.04 1549.52 1794.72 1549.52 Q1792.55 1549.52 1790.28 1549.15 Q1788.03 1548.78 1785.63 1548.04 L1785.63 1543.34 Q1787.71 1544.47 1789.93 1545.03 Q1792.15 1545.58 1794.63 1545.58 Q1798.64 1545.58 1800.97 1543.48 Q1803.31 1541.37 1803.31 1537.76 Q1803.31 1534.15 1800.97 1532.04 Q1798.64 1529.94 1794.63 1529.94 Q1792.76 1529.94 1790.88 1530.35 Q1789.03 1530.77 1787.08 1531.65 L1787.08 1514.29 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M2270.43 1544.91 L2286.75 1544.91 L2286.75 1548.85 L2264.81 1548.85 L2264.81 1544.91 Q2267.47 1542.16 2272.05 1537.53 Q2276.66 1532.88 2277.84 1531.53 Q2280.08 1529.01 2280.96 1527.27 Q2281.87 1525.51 2281.87 1523.82 Q2281.87 1521.07 2279.92 1519.33 Q2278 1517.6 2274.9 1517.6 Q2272.7 1517.6 2270.25 1518.36 Q2267.81 1519.13 2265.04 1520.68 L2265.04 1515.95 Q2267.86 1514.82 2270.31 1514.24 Q2272.77 1513.66 2274.81 1513.66 Q2280.18 1513.66 2283.37 1516.35 Q2286.56 1519.03 2286.56 1523.52 Q2286.56 1525.65 2285.75 1527.57 Q2284.97 1529.47 2282.86 1532.07 Q2282.28 1532.74 2279.18 1535.95 Q2276.08 1539.15 2270.43 1544.91 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M2306.56 1517.37 Q2302.95 1517.37 2301.12 1520.93 Q2299.32 1524.47 2299.32 1531.6 Q2299.32 1538.71 2301.12 1542.27 Q2302.95 1545.82 2306.56 1545.82 Q2310.2 1545.82 2312 1542.27 Q2313.83 1538.71 2313.83 1531.6 Q2313.83 1524.47 2312 1520.93 Q2310.2 1517.37 2306.56 1517.37 M2306.56 1513.66 Q2312.37 1513.66 2315.43 1518.27 Q2318.51 1522.85 2318.51 1531.6 Q2318.51 1540.33 2315.43 1544.94 Q2312.37 1549.52 2306.56 1549.52 Q2300.75 1549.52 2297.68 1544.94 Q2294.62 1540.33 2294.62 1531.6 Q2294.62 1522.85 2297.68 1518.27 Q2300.75 1513.66 2306.56 1513.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,1445.72 2352.76,1445.72 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,1106.21 2352.76,1106.21 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,766.705 2352.76,766.705 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,427.196 2352.76,427.196 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip482)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,87.6867 2352.76,87.6867 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1486.45 193.936,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1445.72 212.834,1445.72 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1106.21 212.834,1106.21 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,766.705 212.834,766.705 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,427.196 212.834,427.196 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,87.6867 212.834,87.6867 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip480)\" d=\"M50.9921 1446.17 L80.6679 1446.17 L80.6679 1450.11 L50.9921 1450.11 L50.9921 1446.17 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M91.5706 1459.07 L99.2095 1459.07 L99.2095 1432.7 L90.8993 1434.37 L90.8993 1430.11 L99.1632 1428.44 L103.839 1428.44 L103.839 1459.07 L111.478 1459.07 L111.478 1463 L91.5706 1463 L91.5706 1459.07 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M120.922 1457.12 L125.807 1457.12 L125.807 1463 L120.922 1463 L120.922 1457.12 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M145.992 1431.52 Q142.381 1431.52 140.552 1435.09 Q138.746 1438.63 138.746 1445.76 Q138.746 1452.86 140.552 1456.43 Q142.381 1459.97 145.992 1459.97 Q149.626 1459.97 151.431 1456.43 Q153.26 1452.86 153.26 1445.76 Q153.26 1438.63 151.431 1435.09 Q149.626 1431.52 145.992 1431.52 M145.992 1427.82 Q151.802 1427.82 154.857 1432.42 Q157.936 1437.01 157.936 1445.76 Q157.936 1454.48 154.857 1459.09 Q151.802 1463.67 145.992 1463.67 Q140.181 1463.67 137.103 1459.09 Q134.047 1454.48 134.047 1445.76 Q134.047 1437.01 137.103 1432.42 Q140.181 1427.82 145.992 1427.82 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M51.9875 1106.66 L81.6633 1106.66 L81.6633 1110.6 L51.9875 1110.6 L51.9875 1106.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M101.756 1092.01 Q98.1447 1092.01 96.316 1095.58 Q94.5104 1099.12 94.5104 1106.25 Q94.5104 1113.35 96.316 1116.92 Q98.1447 1120.46 101.756 1120.46 Q105.39 1120.46 107.196 1116.92 Q109.024 1113.35 109.024 1106.25 Q109.024 1099.12 107.196 1095.58 Q105.39 1092.01 101.756 1092.01 M101.756 1088.31 Q107.566 1088.31 110.621 1092.91 Q113.7 1097.5 113.7 1106.25 Q113.7 1114.97 110.621 1119.58 Q107.566 1124.16 101.756 1124.16 Q95.9456 1124.16 92.8669 1119.58 Q89.8114 1114.97 89.8114 1106.25 Q89.8114 1097.5 92.8669 1092.91 Q95.9456 1088.31 101.756 1088.31 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M121.918 1117.61 L126.802 1117.61 L126.802 1123.49 L121.918 1123.49 L121.918 1117.61 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M137.033 1088.93 L155.39 1088.93 L155.39 1092.87 L141.316 1092.87 L141.316 1101.34 Q142.334 1100.99 143.353 1100.83 Q144.371 1100.65 145.39 1100.65 Q151.177 1100.65 154.556 1103.82 Q157.936 1106.99 157.936 1112.41 Q157.936 1117.98 154.464 1121.09 Q150.992 1124.16 144.672 1124.16 Q142.496 1124.16 140.228 1123.79 Q137.982 1123.42 135.575 1122.68 L135.575 1117.98 Q137.658 1119.12 139.881 1119.67 Q142.103 1120.23 144.58 1120.23 Q148.584 1120.23 150.922 1118.12 Q153.26 1116.02 153.26 1112.41 Q153.26 1108.79 150.922 1106.69 Q148.584 1104.58 144.58 1104.58 Q142.705 1104.58 140.83 1105 Q138.978 1105.41 137.033 1106.29 L137.033 1088.93 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M100.76 752.503 Q97.1493 752.503 95.3206 756.068 Q93.515 759.61 93.515 766.739 Q93.515 773.846 95.3206 777.411 Q97.1493 780.952 100.76 780.952 Q104.395 780.952 106.2 777.411 Q108.029 773.846 108.029 766.739 Q108.029 759.61 106.2 756.068 Q104.395 752.503 100.76 752.503 M100.76 748.8 Q106.571 748.8 109.626 753.406 Q112.705 757.989 112.705 766.739 Q112.705 775.466 109.626 780.073 Q106.571 784.656 100.76 784.656 Q94.9502 784.656 91.8715 780.073 Q88.816 775.466 88.816 766.739 Q88.816 757.989 91.8715 753.406 Q94.9502 748.8 100.76 748.8 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M120.922 778.105 L125.807 778.105 L125.807 783.985 L120.922 783.985 L120.922 778.105 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M145.992 752.503 Q142.381 752.503 140.552 756.068 Q138.746 759.61 138.746 766.739 Q138.746 773.846 140.552 777.411 Q142.381 780.952 145.992 780.952 Q149.626 780.952 151.431 777.411 Q153.26 773.846 153.26 766.739 Q153.26 759.61 151.431 756.068 Q149.626 752.503 145.992 752.503 M145.992 748.8 Q151.802 748.8 154.857 753.406 Q157.936 757.989 157.936 766.739 Q157.936 775.466 154.857 780.073 Q151.802 784.656 145.992 784.656 Q140.181 784.656 137.103 780.073 Q134.047 775.466 134.047 766.739 Q134.047 757.989 137.103 753.406 Q140.181 748.8 145.992 748.8 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M101.756 412.994 Q98.1447 412.994 96.316 416.559 Q94.5104 420.101 94.5104 427.23 Q94.5104 434.337 96.316 437.902 Q98.1447 441.443 101.756 441.443 Q105.39 441.443 107.196 437.902 Q109.024 434.337 109.024 427.23 Q109.024 420.101 107.196 416.559 Q105.39 412.994 101.756 412.994 M101.756 409.291 Q107.566 409.291 110.621 413.897 Q113.7 418.48 113.7 427.23 Q113.7 435.957 110.621 440.564 Q107.566 445.147 101.756 445.147 Q95.9456 445.147 92.8669 440.564 Q89.8114 435.957 89.8114 427.23 Q89.8114 418.48 92.8669 413.897 Q95.9456 409.291 101.756 409.291 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M121.918 438.596 L126.802 438.596 L126.802 444.476 L121.918 444.476 L121.918 438.596 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M137.033 409.916 L155.39 409.916 L155.39 413.851 L141.316 413.851 L141.316 422.323 Q142.334 421.976 143.353 421.814 Q144.371 421.629 145.39 421.629 Q151.177 421.629 154.556 424.8 Q157.936 427.971 157.936 433.388 Q157.936 438.966 154.464 442.068 Q150.992 445.147 144.672 445.147 Q142.496 445.147 140.228 444.777 Q137.982 444.406 135.575 443.665 L135.575 438.966 Q137.658 440.101 139.881 440.656 Q142.103 441.212 144.58 441.212 Q148.584 441.212 150.922 439.105 Q153.26 436.999 153.26 433.388 Q153.26 429.777 150.922 427.67 Q148.584 425.564 144.58 425.564 Q142.705 425.564 140.83 425.98 Q138.978 426.397 137.033 427.277 L137.033 409.916 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M91.5706 101.032 L99.2095 101.032 L99.2095 74.666 L90.8993 76.3326 L90.8993 72.0734 L99.1632 70.4067 L103.839 70.4067 L103.839 101.032 L111.478 101.032 L111.478 104.967 L91.5706 104.967 L91.5706 101.032 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M120.922 99.0871 L125.807 99.0871 L125.807 104.967 L120.922 104.967 L120.922 99.0871 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M145.992 73.4854 Q142.381 73.4854 140.552 77.0502 Q138.746 80.5919 138.746 87.7215 Q138.746 94.8279 140.552 98.3927 Q142.381 101.934 145.992 101.934 Q149.626 101.934 151.431 98.3927 Q153.26 94.8279 153.26 87.7215 Q153.26 80.5919 151.431 77.0502 Q149.626 73.4854 145.992 73.4854 M145.992 69.7817 Q151.802 69.7817 154.857 74.3882 Q157.936 78.9715 157.936 87.7215 Q157.936 96.4483 154.857 101.055 Q151.802 105.638 145.992 105.638 Q140.181 105.638 137.103 101.055 Q134.047 96.4483 134.047 87.7215 Q134.047 78.9715 137.103 74.3882 Q140.181 69.7817 145.992 69.7817 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip482)\" style=\"stroke:#009af9; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  255.035,766.705 265.218,698.916 275.401,631.805 285.584,566.041 295.767,502.283 305.95,441.166 316.133,383.302 326.316,329.269 336.5,279.607 346.683,234.812 \n",
       "  356.866,195.331 367.049,161.559 377.232,133.833 387.415,112.431 397.598,97.5666 407.781,89.3877 417.964,87.9763 428.148,93.3465 438.331,105.445 448.514,124.15 \n",
       "  458.697,149.275 468.88,180.57 479.063,217.721 489.246,260.357 499.429,308.053 509.612,360.331 519.796,416.67 529.979,476.506 540.162,539.242 550.345,604.25 \n",
       "  560.528,670.882 570.711,738.471 580.894,806.342 591.077,873.817 601.261,940.222 611.444,1004.89 621.627,1067.18 631.81,1126.47 641.993,1182.17 652.176,1233.71 \n",
       "  662.359,1280.59 672.542,1322.33 682.725,1358.52 692.909,1388.8 703.092,1412.86 713.275,1430.46 723.458,1441.44 733.641,1445.67 743.824,1443.12 754.007,1433.81 \n",
       "  764.19,1417.83 774.373,1395.35 784.557,1366.59 794.74,1331.83 804.923,1291.43 815.106,1245.78 825.289,1195.35 835.472,1140.63 845.655,1082.18 855.838,1020.57 \n",
       "  866.021,956.433 876.205,890.396 886.388,823.124 896.571,755.288 906.754,687.566 916.937,620.634 927.12,555.162 937.303,491.804 947.486,431.193 957.669,373.934 \n",
       "  967.853,320.599 978.036,271.722 988.219,227.79 998.402,189.243 1008.59,156.466 1018.77,129.786 1028.95,109.47 1039.13,95.7207 1049.32,88.6758 1059.5,88.4056 \n",
       "  1069.68,94.9127 1079.87,108.132 1090.05,127.932 1100.23,154.114 1110.42,186.417 1120.6,224.518 1130.78,268.036 1140.97,316.537 1151.15,369.535 1161.33,426.502 \n",
       "  1171.51,486.869 1181.7,550.031 1191.88,615.358 1202.06,682.198 1212.25,749.882 1222.43,817.733 1232.61,885.076 1242.8,951.235 1252.98,1015.55 1263.16,1077.38 \n",
       "  1273.35,1136.1 1283.53,1191.14 1293.71,1241.93 1303.9,1287.98 1314.08,1328.81 1324.26,1364.03 1334.44,1393.29 1344.63,1416.28 1354.81,1432.78 1364.99,1442.62 \n",
       "  1375.18,1445.72 1385.36,1442.02 1395.54,1431.58 1405.73,1414.5 1415.91,1390.94 1426.09,1361.15 1436.28,1325.42 1446.46,1284.1 1456.64,1237.62 1466.83,1186.43 \n",
       "  1477.01,1131.05 1487.19,1072.02 1497.37,1009.95 1507.56,945.444 1517.74,879.153 1527.92,811.738 1538.11,743.874 1548.29,676.238 1558.47,609.505 1568.66,544.344 \n",
       "  1578.84,481.404 1589.02,421.314 1599.21,364.676 1609.39,312.055 1619.57,263.976 1629.75,220.921 1639.94,183.318 1650.12,151.545 1660.3,125.918 1670.49,106.694 \n",
       "  1680.67,94.0645 1690.85,88.1557 1701.04,89.0267 1711.22,96.6688 1721.4,111.006 1731.59,131.894 1741.77,159.125 1751.95,192.427 1762.14,231.467 1772.32,275.855 \n",
       "  1782.5,325.148 1792.68,378.852 1802.87,436.431 1813.05,497.311 1823.23,560.882 1833.42,626.509 1843.6,693.538 1853.78,761.297 1863.97,829.111 1874.15,896.301 \n",
       "  1884.33,962.196 1894.52,1026.14 1904.7,1087.49 1914.88,1145.63 1925.07,1199.99 1935.25,1250.02 1945.43,1295.22 1955.61,1335.14 1965.8,1369.38 1975.98,1397.6 \n",
       "  1986.16,1419.51 1996.35,1434.9 2006.53,1443.62 2016.71,1445.57 2026.9,1440.74 2037.08,1429.17 2047.26,1410.99 2057.45,1386.36 2067.63,1355.55 2077.81,1318.85 \n",
       "  2087.99,1276.64 2098.18,1229.33 2108.36,1177.4 2118.54,1121.36 2128.73,1061.78 2138.91,999.255 2149.09,934.404 2159.28,867.878 2169.46,800.34 2179.64,732.467 \n",
       "  2189.83,664.935 2200.01,598.421 2210.19,533.588 2220.38,471.084 2230.56,411.534 2240.74,355.532 2250.92,303.639 2261.11,256.373 2271.29,214.206 2281.47,177.559 \n",
       "  2291.66,146.798 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip480)\" d=\"\n",
       "M1988.36 198.898 L2280.8 198.898 L2280.8 95.2176 L1988.36 95.2176  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1988.36,198.898 2280.8,198.898 2280.8,95.2176 1988.36,95.2176 1988.36,198.898 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip480)\" style=\"stroke:#009af9; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2012.36,147.058 2156.36,147.058 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip480)\" d=\"M2194.21 166.745 Q2192.4 171.375 2190.69 172.787 Q2188.98 174.199 2186.11 174.199 L2182.7 174.199 L2182.7 170.634 L2185.2 170.634 Q2186.96 170.634 2187.93 169.8 Q2188.91 168.967 2190.09 165.865 L2190.85 163.921 L2180.36 138.412 L2184.88 138.412 L2192.98 158.689 L2201.08 138.412 L2205.6 138.412 L2194.21 166.745 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip480)\" d=\"M2212.89 160.402 L2220.53 160.402 L2220.53 134.037 L2212.22 135.703 L2212.22 131.444 L2220.48 129.778 L2225.16 129.778 L2225.16 160.402 L2232.8 160.402 L2232.8 164.338 L2212.89 164.338 L2212.89 160.402 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /></svg>\n"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(xs, ys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add titles, legends, colors and other components with keywords. You can check the [Plots.jl](https://juliaplots.org/) package documentation for the different keywords for plots. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip520\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<path clip-path=\"url(#clip520)\" d=\"\n",
       "M0 1600 L2400 1600 L2400 0 L0 0  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip521\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<path clip-path=\"url(#clip520)\" d=\"\n",
       "M193.936 1486.45 L2352.76 1486.45 L2352.76 123.472 L193.936 123.472  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip522\">\n",
       "    <rect x=\"193\" y=\"123\" width=\"2160\" height=\"1364\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  255.035,1486.45 255.035,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  764.19,1486.45 764.19,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1273.35,1486.45 1273.35,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1782.5,1486.45 1782.5,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2291.66,1486.45 2291.66,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1486.45 2352.76,1486.45 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  255.035,1486.45 255.035,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  764.19,1486.45 764.19,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1273.35,1486.45 1273.35,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1782.5,1486.45 1782.5,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2291.66,1486.45 2291.66,1467.55 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip520)\" d=\"M255.035 1517.37 Q251.424 1517.37 249.595 1520.93 Q247.789 1524.47 247.789 1531.6 Q247.789 1538.71 249.595 1542.27 Q251.424 1545.82 255.035 1545.82 Q258.669 1545.82 260.474 1542.27 Q262.303 1538.71 262.303 1531.6 Q262.303 1524.47 260.474 1520.93 Q258.669 1517.37 255.035 1517.37 M255.035 1513.66 Q260.845 1513.66 263.9 1518.27 Q266.979 1522.85 266.979 1531.6 Q266.979 1540.33 263.9 1544.94 Q260.845 1549.52 255.035 1549.52 Q249.225 1549.52 246.146 1544.94 Q243.09 1540.33 243.09 1531.6 Q243.09 1522.85 246.146 1518.27 Q249.225 1513.66 255.035 1513.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M754.468 1514.29 L772.825 1514.29 L772.825 1518.22 L758.751 1518.22 L758.751 1526.7 Q759.769 1526.35 760.788 1526.19 Q761.806 1526 762.825 1526 Q768.612 1526 771.991 1529.17 Q775.371 1532.34 775.371 1537.76 Q775.371 1543.34 771.899 1546.44 Q768.426 1549.52 762.107 1549.52 Q759.931 1549.52 757.663 1549.15 Q755.417 1548.78 753.01 1548.04 L753.01 1543.34 Q755.093 1544.47 757.315 1545.03 Q759.538 1545.58 762.014 1545.58 Q766.019 1545.58 768.357 1543.48 Q770.695 1541.37 770.695 1537.76 Q770.695 1534.15 768.357 1532.04 Q766.019 1529.94 762.014 1529.94 Q760.139 1529.94 758.264 1530.35 Q756.413 1530.77 754.468 1531.65 L754.468 1514.29 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1248.03 1544.91 L1255.67 1544.91 L1255.67 1518.55 L1247.36 1520.21 L1247.36 1515.95 L1255.63 1514.29 L1260.3 1514.29 L1260.3 1544.91 L1267.94 1544.91 L1267.94 1548.85 L1248.03 1548.85 L1248.03 1544.91 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1287.39 1517.37 Q1283.77 1517.37 1281.95 1520.93 Q1280.14 1524.47 1280.14 1531.6 Q1280.14 1538.71 1281.95 1542.27 Q1283.77 1545.82 1287.39 1545.82 Q1291.02 1545.82 1292.83 1542.27 Q1294.65 1538.71 1294.65 1531.6 Q1294.65 1524.47 1292.83 1520.93 Q1291.02 1517.37 1287.39 1517.37 M1287.39 1513.66 Q1293.2 1513.66 1296.25 1518.27 Q1299.33 1522.85 1299.33 1531.6 Q1299.33 1540.33 1296.25 1544.94 Q1293.2 1549.52 1287.39 1549.52 Q1281.58 1549.52 1278.5 1544.94 Q1275.44 1540.33 1275.44 1531.6 Q1275.44 1522.85 1278.5 1518.27 Q1281.58 1513.66 1287.39 1513.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1757.69 1544.91 L1765.33 1544.91 L1765.33 1518.55 L1757.02 1520.21 L1757.02 1515.95 L1765.28 1514.29 L1769.96 1514.29 L1769.96 1544.91 L1777.59 1544.91 L1777.59 1548.85 L1757.69 1548.85 L1757.69 1544.91 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1787.08 1514.29 L1805.44 1514.29 L1805.44 1518.22 L1791.37 1518.22 L1791.37 1526.7 Q1792.39 1526.35 1793.4 1526.19 Q1794.42 1526 1795.44 1526 Q1801.23 1526 1804.61 1529.17 Q1807.99 1532.34 1807.99 1537.76 Q1807.99 1543.34 1804.52 1546.44 Q1801.04 1549.52 1794.72 1549.52 Q1792.55 1549.52 1790.28 1549.15 Q1788.03 1548.78 1785.63 1548.04 L1785.63 1543.34 Q1787.71 1544.47 1789.93 1545.03 Q1792.15 1545.58 1794.63 1545.58 Q1798.64 1545.58 1800.97 1543.48 Q1803.31 1541.37 1803.31 1537.76 Q1803.31 1534.15 1800.97 1532.04 Q1798.64 1529.94 1794.63 1529.94 Q1792.76 1529.94 1790.88 1530.35 Q1789.03 1530.77 1787.08 1531.65 L1787.08 1514.29 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M2270.43 1544.91 L2286.75 1544.91 L2286.75 1548.85 L2264.81 1548.85 L2264.81 1544.91 Q2267.47 1542.16 2272.05 1537.53 Q2276.66 1532.88 2277.84 1531.53 Q2280.08 1529.01 2280.96 1527.27 Q2281.87 1525.51 2281.87 1523.82 Q2281.87 1521.07 2279.92 1519.33 Q2278 1517.6 2274.9 1517.6 Q2272.7 1517.6 2270.25 1518.36 Q2267.81 1519.13 2265.04 1520.68 L2265.04 1515.95 Q2267.86 1514.82 2270.31 1514.24 Q2272.77 1513.66 2274.81 1513.66 Q2280.18 1513.66 2283.37 1516.35 Q2286.56 1519.03 2286.56 1523.52 Q2286.56 1525.65 2285.75 1527.57 Q2284.97 1529.47 2282.86 1532.07 Q2282.28 1532.74 2279.18 1535.95 Q2276.08 1539.15 2270.43 1544.91 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M2306.56 1517.37 Q2302.95 1517.37 2301.12 1520.93 Q2299.32 1524.47 2299.32 1531.6 Q2299.32 1538.71 2301.12 1542.27 Q2302.95 1545.82 2306.56 1545.82 Q2310.2 1545.82 2312 1542.27 Q2313.83 1538.71 2313.83 1531.6 Q2313.83 1524.47 2312 1520.93 Q2310.2 1517.37 2306.56 1517.37 M2306.56 1513.66 Q2312.37 1513.66 2315.43 1518.27 Q2318.51 1522.85 2318.51 1531.6 Q2318.51 1540.33 2315.43 1544.94 Q2312.37 1549.52 2306.56 1549.52 Q2300.75 1549.52 2297.68 1544.94 Q2294.62 1540.33 2294.62 1531.6 Q2294.62 1522.85 2297.68 1518.27 Q2300.75 1513.66 2306.56 1513.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,1447.88 2352.76,1447.88 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,1126.35 2352.76,1126.35 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,804.826 2352.76,804.826 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,483.299 2352.76,483.299 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip522)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,161.773 2352.76,161.773 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1486.45 193.936,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1447.88 212.834,1447.88 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1126.35 212.834,1126.35 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,804.826 212.834,804.826 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,483.299 212.834,483.299 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip520)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,161.773 212.834,161.773 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip520)\" d=\"M50.9921 1448.33 L80.6679 1448.33 L80.6679 1452.27 L50.9921 1452.27 L50.9921 1448.33 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M91.5706 1461.22 L99.2095 1461.22 L99.2095 1434.86 L90.8993 1436.53 L90.8993 1432.27 L99.1632 1430.6 L103.839 1430.6 L103.839 1461.22 L111.478 1461.22 L111.478 1465.16 L91.5706 1465.16 L91.5706 1461.22 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M120.922 1459.28 L125.807 1459.28 L125.807 1465.16 L120.922 1465.16 L120.922 1459.28 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M145.992 1433.68 Q142.381 1433.68 140.552 1437.24 Q138.746 1440.78 138.746 1447.91 Q138.746 1455.02 140.552 1458.59 Q142.381 1462.13 145.992 1462.13 Q149.626 1462.13 151.431 1458.59 Q153.26 1455.02 153.26 1447.91 Q153.26 1440.78 151.431 1437.24 Q149.626 1433.68 145.992 1433.68 M145.992 1429.97 Q151.802 1429.97 154.857 1434.58 Q157.936 1439.16 157.936 1447.91 Q157.936 1456.64 154.857 1461.25 Q151.802 1465.83 145.992 1465.83 Q140.181 1465.83 137.103 1461.25 Q134.047 1456.64 134.047 1447.91 Q134.047 1439.16 137.103 1434.58 Q140.181 1429.97 145.992 1429.97 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M51.9875 1126.8 L81.6633 1126.8 L81.6633 1130.74 L51.9875 1130.74 L51.9875 1126.8 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M101.756 1112.15 Q98.1447 1112.15 96.316 1115.72 Q94.5104 1119.26 94.5104 1126.39 Q94.5104 1133.49 96.316 1137.06 Q98.1447 1140.6 101.756 1140.6 Q105.39 1140.6 107.196 1137.06 Q109.024 1133.49 109.024 1126.39 Q109.024 1119.26 107.196 1115.72 Q105.39 1112.15 101.756 1112.15 M101.756 1108.45 Q107.566 1108.45 110.621 1113.05 Q113.7 1117.64 113.7 1126.39 Q113.7 1135.11 110.621 1139.72 Q107.566 1144.3 101.756 1144.3 Q95.9456 1144.3 92.8669 1139.72 Q89.8114 1135.11 89.8114 1126.39 Q89.8114 1117.64 92.8669 1113.05 Q95.9456 1108.45 101.756 1108.45 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M121.918 1137.75 L126.802 1137.75 L126.802 1143.63 L121.918 1143.63 L121.918 1137.75 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M137.033 1109.07 L155.39 1109.07 L155.39 1113.01 L141.316 1113.01 L141.316 1121.48 Q142.334 1121.13 143.353 1120.97 Q144.371 1120.79 145.39 1120.79 Q151.177 1120.79 154.556 1123.96 Q157.936 1127.13 157.936 1132.54 Q157.936 1138.12 154.464 1141.23 Q150.992 1144.3 144.672 1144.3 Q142.496 1144.3 140.228 1143.93 Q137.982 1143.56 135.575 1142.82 L135.575 1138.12 Q137.658 1139.26 139.881 1139.81 Q142.103 1140.37 144.58 1140.37 Q148.584 1140.37 150.922 1138.26 Q153.26 1136.16 153.26 1132.54 Q153.26 1128.93 150.922 1126.83 Q148.584 1124.72 144.58 1124.72 Q142.705 1124.72 140.83 1125.14 Q138.978 1125.55 137.033 1126.43 L137.033 1109.07 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M100.76 790.625 Q97.1493 790.625 95.3206 794.19 Q93.515 797.731 93.515 804.861 Q93.515 811.967 95.3206 815.532 Q97.1493 819.074 100.76 819.074 Q104.395 819.074 106.2 815.532 Q108.029 811.967 108.029 804.861 Q108.029 797.731 106.2 794.19 Q104.395 790.625 100.76 790.625 M100.76 786.921 Q106.571 786.921 109.626 791.528 Q112.705 796.111 112.705 804.861 Q112.705 813.588 109.626 818.194 Q106.571 822.777 100.76 822.777 Q94.9502 822.777 91.8715 818.194 Q88.816 813.588 88.816 804.861 Q88.816 796.111 91.8715 791.528 Q94.9502 786.921 100.76 786.921 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M120.922 816.226 L125.807 816.226 L125.807 822.106 L120.922 822.106 L120.922 816.226 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M145.992 790.625 Q142.381 790.625 140.552 794.19 Q138.746 797.731 138.746 804.861 Q138.746 811.967 140.552 815.532 Q142.381 819.074 145.992 819.074 Q149.626 819.074 151.431 815.532 Q153.26 811.967 153.26 804.861 Q153.26 797.731 151.431 794.19 Q149.626 790.625 145.992 790.625 M145.992 786.921 Q151.802 786.921 154.857 791.528 Q157.936 796.111 157.936 804.861 Q157.936 813.588 154.857 818.194 Q151.802 822.777 145.992 822.777 Q140.181 822.777 137.103 818.194 Q134.047 813.588 134.047 804.861 Q134.047 796.111 137.103 791.528 Q140.181 786.921 145.992 786.921 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M101.756 469.098 Q98.1447 469.098 96.316 472.663 Q94.5104 476.205 94.5104 483.334 Q94.5104 490.441 96.316 494.005 Q98.1447 497.547 101.756 497.547 Q105.39 497.547 107.196 494.005 Q109.024 490.441 109.024 483.334 Q109.024 476.205 107.196 472.663 Q105.39 469.098 101.756 469.098 M101.756 465.394 Q107.566 465.394 110.621 470.001 Q113.7 474.584 113.7 483.334 Q113.7 492.061 110.621 496.667 Q107.566 501.251 101.756 501.251 Q95.9456 501.251 92.8669 496.667 Q89.8114 492.061 89.8114 483.334 Q89.8114 474.584 92.8669 470.001 Q95.9456 465.394 101.756 465.394 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M121.918 494.7 L126.802 494.7 L126.802 500.579 L121.918 500.579 L121.918 494.7 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M137.033 466.019 L155.39 466.019 L155.39 469.955 L141.316 469.955 L141.316 478.427 Q142.334 478.08 143.353 477.917 Q144.371 477.732 145.39 477.732 Q151.177 477.732 154.556 480.904 Q157.936 484.075 157.936 489.491 Q157.936 495.07 154.464 498.172 Q150.992 501.251 144.672 501.251 Q142.496 501.251 140.228 500.88 Q137.982 500.51 135.575 499.769 L135.575 495.07 Q137.658 496.204 139.881 496.76 Q142.103 497.316 144.58 497.316 Q148.584 497.316 150.922 495.209 Q153.26 493.103 153.26 489.491 Q153.26 485.88 150.922 483.774 Q148.584 481.667 144.58 481.667 Q142.705 481.667 140.83 482.084 Q138.978 482.501 137.033 483.38 L137.033 466.019 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M91.5706 175.118 L99.2095 175.118 L99.2095 148.752 L90.8993 150.419 L90.8993 146.159 L99.1632 144.493 L103.839 144.493 L103.839 175.118 L111.478 175.118 L111.478 179.053 L91.5706 179.053 L91.5706 175.118 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M120.922 173.173 L125.807 173.173 L125.807 179.053 L120.922 179.053 L120.922 173.173 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M145.992 147.571 Q142.381 147.571 140.552 151.136 Q138.746 154.678 138.746 161.807 Q138.746 168.914 140.552 172.479 Q142.381 176.02 145.992 176.02 Q149.626 176.02 151.431 172.479 Q153.26 168.914 153.26 161.807 Q153.26 154.678 151.431 151.136 Q149.626 147.571 145.992 147.571 M145.992 143.868 Q151.802 143.868 154.857 148.474 Q157.936 153.057 157.936 161.807 Q157.936 170.534 154.857 175.141 Q151.802 179.724 145.992 179.724 Q140.181 179.724 137.103 175.141 Q134.047 170.534 134.047 161.807 Q134.047 153.057 137.103 148.474 Q140.181 143.868 145.992 143.868 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1041.78 17.6457 Q1032.86 17.6457 1027.6 24.2892 Q1022.37 30.9327 1022.37 42.3968 Q1022.37 53.8203 1027.6 60.4638 Q1032.86 67.1073 1041.78 67.1073 Q1050.69 67.1073 1055.87 60.4638 Q1061.1 53.8203 1061.1 42.3968 Q1061.1 30.9327 1055.87 24.2892 Q1050.69 17.6457 1041.78 17.6457 M1041.78 11.0023 Q1054.5 11.0023 1062.11 19.5497 Q1069.73 28.0566 1069.73 42.3968 Q1069.73 56.6965 1062.11 65.2439 Q1054.5 73.7508 1041.78 73.7508 Q1029.02 73.7508 1021.36 65.2439 Q1013.74 56.737 1013.74 42.3968 Q1013.74 28.0566 1021.36 19.5497 Q1029.02 11.0023 1041.78 11.0023 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1081.43 54.671 L1081.43 27.2059 L1088.89 27.2059 L1088.89 54.3874 Q1088.89 60.8284 1091.4 64.0691 Q1093.91 67.2693 1098.93 67.2693 Q1104.97 67.2693 1108.45 63.421 Q1111.98 59.5726 1111.98 52.9291 L1111.98 27.2059 L1119.43 27.2059 L1119.43 72.576 L1111.98 72.576 L1111.98 65.6084 Q1109.26 69.7404 1105.66 71.7658 Q1102.09 73.7508 1097.35 73.7508 Q1089.54 73.7508 1085.49 68.8897 Q1081.43 64.0286 1081.43 54.671 M1100.19 26.1121 L1100.19 26.1121 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1161.08 34.1734 Q1159.82 33.4443 1158.32 33.1202 Q1156.86 32.7556 1155.08 32.7556 Q1148.76 32.7556 1145.36 36.8875 Q1142 40.9789 1142 48.6757 L1142 72.576 L1134.5 72.576 L1134.5 27.2059 L1142 27.2059 L1142 34.2544 Q1144.34 30.1225 1148.11 28.1376 Q1151.88 26.1121 1157.27 26.1121 Q1158.04 26.1121 1158.97 26.2337 Q1159.9 26.3147 1161.03 26.5172 L1161.08 34.1734 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1218.23 9.54393 L1218.23 15.7418 L1211.1 15.7418 Q1207.09 15.7418 1205.51 17.3622 Q1203.97 18.9825 1203.97 23.1955 L1203.97 27.2059 L1216.25 27.2059 L1216.25 32.9987 L1203.97 32.9987 L1203.97 72.576 L1196.48 72.576 L1196.48 32.9987 L1189.35 32.9987 L1189.35 27.2059 L1196.48 27.2059 L1196.48 24.0462 Q1196.48 16.471 1200 13.0277 Q1203.53 9.54393 1211.18 9.54393 L1218.23 9.54393 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1224.47 27.2059 L1231.93 27.2059 L1231.93 72.576 L1224.47 72.576 L1224.47 27.2059 M1224.47 9.54393 L1231.93 9.54393 L1231.93 18.9825 L1224.47 18.9825 L1224.47 9.54393 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1273.81 34.1734 Q1272.56 33.4443 1271.06 33.1202 Q1269.6 32.7556 1267.82 32.7556 Q1261.5 32.7556 1258.09 36.8875 Q1254.73 40.9789 1254.73 48.6757 L1254.73 72.576 L1247.24 72.576 L1247.24 27.2059 L1254.73 27.2059 L1254.73 34.2544 Q1257.08 30.1225 1260.85 28.1376 Q1264.62 26.1121 1270 26.1121 Q1270.77 26.1121 1271.71 26.2337 Q1272.64 26.3147 1273.77 26.5172 L1273.81 34.1734 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1310.55 28.5427 L1310.55 35.5912 Q1307.39 33.9709 1303.99 33.1607 Q1300.59 32.3505 1296.94 32.3505 Q1291.39 32.3505 1288.6 34.0519 Q1285.84 35.7533 1285.84 39.156 Q1285.84 41.7486 1287.83 43.2475 Q1289.81 44.7058 1295.81 46.0426 L1298.36 46.6097 Q1306.3 48.3111 1309.62 51.4303 Q1312.98 54.509 1312.98 60.0587 Q1312.98 66.3781 1307.96 70.0644 Q1302.98 73.7508 1294.23 73.7508 Q1290.58 73.7508 1286.61 73.0216 Q1282.68 72.3329 1278.31 70.9151 L1278.31 63.2184 Q1282.44 65.3654 1286.45 66.4591 Q1290.46 67.5124 1294.39 67.5124 Q1299.66 67.5124 1302.49 65.73 Q1305.33 63.9071 1305.33 60.6258 Q1305.33 57.5877 1303.26 55.9673 Q1301.24 54.3469 1294.31 52.8481 L1291.72 52.2405 Q1284.79 50.7821 1281.71 47.7845 Q1278.63 44.7463 1278.63 39.4801 Q1278.63 33.0797 1283.17 29.5959 Q1287.71 26.1121 1296.05 26.1121 Q1300.18 26.1121 1303.83 26.7198 Q1307.47 27.3274 1310.55 28.5427 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1332.23 14.324 L1332.23 27.2059 L1347.58 27.2059 L1347.58 32.9987 L1332.23 32.9987 L1332.23 57.6282 Q1332.23 63.1779 1333.72 64.7578 Q1335.26 66.3376 1339.92 66.3376 L1347.58 66.3376 L1347.58 72.576 L1339.92 72.576 Q1331.29 72.576 1328.01 69.3758 Q1324.73 66.1351 1324.73 57.6282 L1324.73 32.9987 L1319.26 32.9987 L1319.26 27.2059 L1324.73 27.2059 L1324.73 14.324 L1332.23 14.324 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1390.96 65.7705 L1390.96 89.8329 L1383.47 89.8329 L1383.47 27.2059 L1390.96 27.2059 L1390.96 34.0924 Q1393.31 30.0415 1396.88 28.0971 Q1400.48 26.1121 1405.47 26.1121 Q1413.73 26.1121 1418.87 32.6746 Q1424.06 39.2371 1424.06 49.9314 Q1424.06 60.6258 1418.87 67.1883 Q1413.73 73.7508 1405.47 73.7508 Q1400.48 73.7508 1396.88 71.8063 Q1393.31 69.8214 1390.96 65.7705 M1416.32 49.9314 Q1416.32 41.7081 1412.92 37.0496 Q1409.56 32.3505 1403.64 32.3505 Q1397.73 32.3505 1394.33 37.0496 Q1390.96 41.7081 1390.96 49.9314 Q1390.96 58.1548 1394.33 62.8538 Q1397.73 67.5124 1403.64 67.5124 Q1409.56 67.5124 1412.92 62.8538 Q1416.32 58.1548 1416.32 49.9314 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1436.42 9.54393 L1443.87 9.54393 L1443.87 72.576 L1436.42 72.576 L1436.42 9.54393 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1477.05 32.4315 Q1471.05 32.4315 1467.57 37.1306 Q1464.08 41.7891 1464.08 49.9314 Q1464.08 58.0738 1467.53 62.7728 Q1471.01 67.4314 1477.05 67.4314 Q1483 67.4314 1486.48 62.7323 Q1489.97 58.0333 1489.97 49.9314 Q1489.97 41.8701 1486.48 37.1711 Q1483 32.4315 1477.05 32.4315 M1477.05 26.1121 Q1486.77 26.1121 1492.32 32.4315 Q1497.87 38.7509 1497.87 49.9314 Q1497.87 61.0714 1492.32 67.4314 Q1486.77 73.7508 1477.05 73.7508 Q1467.28 73.7508 1461.73 67.4314 Q1456.22 61.0714 1456.22 49.9314 Q1456.22 38.7509 1461.73 32.4315 Q1467.28 26.1121 1477.05 26.1121 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip520)\" d=\"M1517.6 14.324 L1517.6 27.2059 L1532.95 27.2059 L1532.95 32.9987 L1517.6 32.9987 L1517.6 57.6282 Q1517.6 63.1779 1519.09 64.7578 Q1520.63 66.3376 1525.29 66.3376 L1532.95 66.3376 L1532.95 72.576 L1525.29 72.576 Q1516.66 72.576 1513.38 69.3758 Q1510.1 66.1351 1510.1 57.6282 L1510.1 32.9987 L1504.63 32.9987 L1504.63 27.2059 L1510.1 27.2059 L1510.1 14.324 L1517.6 14.324 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip522)\" style=\"stroke:#4682b4; stroke-linecap:butt; stroke-linejoin:round; stroke-width:6; stroke-opacity:1; fill:none\" points=\"\n",
       "  255.035,804.826 265.218,740.628 275.401,677.071 285.584,614.791 295.767,554.409 305.95,496.53 316.133,441.731 326.316,390.56 336.5,343.528 346.683,301.105 \n",
       "  356.866,263.715 367.049,231.732 377.232,205.475 387.415,185.207 397.598,171.129 407.781,163.384 417.964,162.047 428.148,167.133 438.331,178.59 448.514,196.305 \n",
       "  458.697,220.099 468.88,249.736 479.063,284.92 489.246,325.298 499.429,370.467 509.612,419.977 519.796,473.331 529.979,529.998 540.162,589.411 550.345,650.976 \n",
       "  560.528,714.078 570.711,778.087 580.894,842.364 591.077,906.265 601.261,969.153 611.444,1030.4 621.627,1089.39 631.81,1145.54 641.993,1198.28 652.176,1247.1 \n",
       "  662.359,1291.49 672.542,1331.02 682.725,1365.3 692.909,1393.97 703.092,1416.76 713.275,1433.43 723.458,1443.82 733.641,1447.83 743.824,1445.41 754.007,1436.6 \n",
       "  764.19,1421.47 774.373,1400.17 784.557,1372.93 794.74,1340.02 804.923,1301.75 815.106,1258.53 825.289,1210.76 835.472,1158.95 845.655,1103.59 855.838,1045.25 \n",
       "  866.021,984.505 876.205,921.966 886.388,858.257 896.571,794.014 906.754,729.879 916.937,666.492 927.12,604.488 937.303,544.486 947.486,487.085 957.669,432.858 \n",
       "  967.853,382.349 978.036,336.06 988.219,294.455 998.402,257.95 1008.59,226.909 1018.77,201.642 1028.95,182.402 1039.13,169.381 1049.32,162.709 1059.5,162.453 \n",
       "  1069.68,168.616 1079.87,181.135 1090.05,199.886 1100.23,224.681 1110.42,255.273 1120.6,291.356 1130.78,332.57 1140.97,378.501 1151.15,428.693 1161.33,482.643 \n",
       "  1171.51,539.812 1181.7,599.629 1191.88,661.496 1202.06,724.795 1212.25,788.894 1222.43,853.152 1232.61,916.927 1242.8,979.583 1252.98,1040.49 1263.16,1099.05 \n",
       "  1273.35,1154.66 1283.53,1206.78 1293.71,1254.88 1303.9,1298.49 1314.08,1337.16 1324.26,1370.52 1334.44,1398.22 1344.63,1419.99 1354.81,1435.62 1364.99,1444.94 \n",
       "  1375.18,1447.87 1385.36,1444.38 1395.54,1434.49 1405.73,1418.31 1415.91,1396 1426.09,1367.79 1436.28,1333.95 1446.46,1294.82 1456.64,1250.8 1466.83,1202.32 \n",
       "  1477.01,1149.87 1487.19,1093.97 1497.37,1035.19 1507.56,974.098 1517.74,911.318 1527.92,847.475 1538.11,783.205 1548.29,719.151 1558.47,655.953 1568.66,594.243 \n",
       "  1578.84,534.636 1589.02,477.73 1599.21,424.091 1609.39,374.257 1619.57,328.725 1629.75,287.95 1639.94,252.339 1650.12,222.249 1660.3,197.979 1670.49,179.773 \n",
       "  1680.67,167.813 1690.85,162.217 1701.04,163.042 1711.22,170.279 1721.4,183.857 1731.59,203.639 1741.77,229.428 1751.95,260.966 1762.14,297.938 1772.32,339.975 \n",
       "  1782.5,386.656 1792.68,437.516 1802.87,492.046 1813.05,549.701 1823.23,609.905 1833.42,672.056 1843.6,735.535 1853.78,799.705 1863.97,863.927 1874.15,927.558 \n",
       "  1884.33,989.963 1894.52,1050.52 1904.7,1108.62 1914.88,1163.68 1925.07,1215.16 1935.25,1262.54 1945.43,1305.35 1955.61,1343.15 1965.8,1375.58 1975.98,1402.3 \n",
       "  1986.16,1423.06 1996.35,1437.63 2006.53,1445.89 2016.71,1447.73 2026.9,1443.16 2037.08,1432.21 2047.26,1414.98 2057.45,1391.67 2067.63,1362.48 2077.81,1327.73 \n",
       "  2087.99,1287.75 2098.18,1242.95 2108.36,1193.77 2118.54,1140.7 2128.73,1084.27 2138.91,1025.06 2149.09,963.643 2159.28,900.64 2169.46,836.68 2179.64,772.402 \n",
       "  2189.83,708.447 2200.01,645.455 2210.19,584.056 2220.38,524.863 2230.56,468.467 2240.74,415.432 2250.92,366.287 2261.11,321.524 2271.29,281.59 2281.47,246.885 \n",
       "  2291.66,217.754 \n",
       "  \"/>\n",
       "</svg>\n"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(xs, ys, color = :steelblue, title = \"Our first plot\", legend = false, lw = 1.5) # lw stands for line width"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another nice feature of plotting is the ability to overlay plots on top of each other. Let us define two different plots and then overlay. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "ys_1 = sin.(xs);\n",
    "ys_2 = cos.(xs);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you look carefully at the second line of the code below you will see that there is a `!` operator. This exclamation mark means that we are mutating / altering the current plot. It is a nice coding convention to indicate to us that the original plot will now be altered. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip560\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<path clip-path=\"url(#clip560)\" d=\"\n",
       "M0 1600 L2400 1600 L2400 0 L0 0  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip561\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<path clip-path=\"url(#clip560)\" d=\"\n",
       "M193.936 1486.45 L2352.76 1486.45 L2352.76 47.2441 L193.936 47.2441  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip562\">\n",
       "    <rect x=\"193\" y=\"47\" width=\"2160\" height=\"1440\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  255.035,1486.45 255.035,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  764.19,1486.45 764.19,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1273.35,1486.45 1273.35,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1782.5,1486.45 1782.5,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2291.66,1486.45 2291.66,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1486.45 2352.76,1486.45 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  255.035,1486.45 255.035,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  764.19,1486.45 764.19,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1273.35,1486.45 1273.35,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1782.5,1486.45 1782.5,1467.55 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2291.66,1486.45 2291.66,1467.55 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip560)\" d=\"M255.035 1517.37 Q251.424 1517.37 249.595 1520.93 Q247.789 1524.47 247.789 1531.6 Q247.789 1538.71 249.595 1542.27 Q251.424 1545.82 255.035 1545.82 Q258.669 1545.82 260.474 1542.27 Q262.303 1538.71 262.303 1531.6 Q262.303 1524.47 260.474 1520.93 Q258.669 1517.37 255.035 1517.37 M255.035 1513.66 Q260.845 1513.66 263.9 1518.27 Q266.979 1522.85 266.979 1531.6 Q266.979 1540.33 263.9 1544.94 Q260.845 1549.52 255.035 1549.52 Q249.225 1549.52 246.146 1544.94 Q243.09 1540.33 243.09 1531.6 Q243.09 1522.85 246.146 1518.27 Q249.225 1513.66 255.035 1513.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M754.468 1514.29 L772.825 1514.29 L772.825 1518.22 L758.751 1518.22 L758.751 1526.7 Q759.769 1526.35 760.788 1526.19 Q761.806 1526 762.825 1526 Q768.612 1526 771.991 1529.17 Q775.371 1532.34 775.371 1537.76 Q775.371 1543.34 771.899 1546.44 Q768.426 1549.52 762.107 1549.52 Q759.931 1549.52 757.663 1549.15 Q755.417 1548.78 753.01 1548.04 L753.01 1543.34 Q755.093 1544.47 757.315 1545.03 Q759.538 1545.58 762.014 1545.58 Q766.019 1545.58 768.357 1543.48 Q770.695 1541.37 770.695 1537.76 Q770.695 1534.15 768.357 1532.04 Q766.019 1529.94 762.014 1529.94 Q760.139 1529.94 758.264 1530.35 Q756.413 1530.77 754.468 1531.65 L754.468 1514.29 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M1248.03 1544.91 L1255.67 1544.91 L1255.67 1518.55 L1247.36 1520.21 L1247.36 1515.95 L1255.63 1514.29 L1260.3 1514.29 L1260.3 1544.91 L1267.94 1544.91 L1267.94 1548.85 L1248.03 1548.85 L1248.03 1544.91 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M1287.39 1517.37 Q1283.77 1517.37 1281.95 1520.93 Q1280.14 1524.47 1280.14 1531.6 Q1280.14 1538.71 1281.95 1542.27 Q1283.77 1545.82 1287.39 1545.82 Q1291.02 1545.82 1292.83 1542.27 Q1294.65 1538.71 1294.65 1531.6 Q1294.65 1524.47 1292.83 1520.93 Q1291.02 1517.37 1287.39 1517.37 M1287.39 1513.66 Q1293.2 1513.66 1296.25 1518.27 Q1299.33 1522.85 1299.33 1531.6 Q1299.33 1540.33 1296.25 1544.94 Q1293.2 1549.52 1287.39 1549.52 Q1281.58 1549.52 1278.5 1544.94 Q1275.44 1540.33 1275.44 1531.6 Q1275.44 1522.85 1278.5 1518.27 Q1281.58 1513.66 1287.39 1513.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M1757.69 1544.91 L1765.33 1544.91 L1765.33 1518.55 L1757.02 1520.21 L1757.02 1515.95 L1765.28 1514.29 L1769.96 1514.29 L1769.96 1544.91 L1777.59 1544.91 L1777.59 1548.85 L1757.69 1548.85 L1757.69 1544.91 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M1787.08 1514.29 L1805.44 1514.29 L1805.44 1518.22 L1791.37 1518.22 L1791.37 1526.7 Q1792.39 1526.35 1793.4 1526.19 Q1794.42 1526 1795.44 1526 Q1801.23 1526 1804.61 1529.17 Q1807.99 1532.34 1807.99 1537.76 Q1807.99 1543.34 1804.52 1546.44 Q1801.04 1549.52 1794.72 1549.52 Q1792.55 1549.52 1790.28 1549.15 Q1788.03 1548.78 1785.63 1548.04 L1785.63 1543.34 Q1787.71 1544.47 1789.93 1545.03 Q1792.15 1545.58 1794.63 1545.58 Q1798.64 1545.58 1800.97 1543.48 Q1803.31 1541.37 1803.31 1537.76 Q1803.31 1534.15 1800.97 1532.04 Q1798.64 1529.94 1794.63 1529.94 Q1792.76 1529.94 1790.88 1530.35 Q1789.03 1530.77 1787.08 1531.65 L1787.08 1514.29 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M2270.43 1544.91 L2286.75 1544.91 L2286.75 1548.85 L2264.81 1548.85 L2264.81 1544.91 Q2267.47 1542.16 2272.05 1537.53 Q2276.66 1532.88 2277.84 1531.53 Q2280.08 1529.01 2280.96 1527.27 Q2281.87 1525.51 2281.87 1523.82 Q2281.87 1521.07 2279.92 1519.33 Q2278 1517.6 2274.9 1517.6 Q2272.7 1517.6 2270.25 1518.36 Q2267.81 1519.13 2265.04 1520.68 L2265.04 1515.95 Q2267.86 1514.82 2270.31 1514.24 Q2272.77 1513.66 2274.81 1513.66 Q2280.18 1513.66 2283.37 1516.35 Q2286.56 1519.03 2286.56 1523.52 Q2286.56 1525.65 2285.75 1527.57 Q2284.97 1529.47 2282.86 1532.07 Q2282.28 1532.74 2279.18 1535.95 Q2276.08 1539.15 2270.43 1544.91 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M2306.56 1517.37 Q2302.95 1517.37 2301.12 1520.93 Q2299.32 1524.47 2299.32 1531.6 Q2299.32 1538.71 2301.12 1542.27 Q2302.95 1545.82 2306.56 1545.82 Q2310.2 1545.82 2312 1542.27 Q2313.83 1538.71 2313.83 1531.6 Q2313.83 1524.47 2312 1520.93 Q2310.2 1517.37 2306.56 1517.37 M2306.56 1513.66 Q2312.37 1513.66 2315.43 1518.27 Q2318.51 1522.85 2318.51 1531.6 Q2318.51 1540.33 2315.43 1544.94 Q2312.37 1549.52 2306.56 1549.52 Q2300.75 1549.52 2297.68 1544.94 Q2294.62 1540.33 2294.62 1531.6 Q2294.62 1522.85 2297.68 1518.27 Q2300.75 1513.66 2306.56 1513.66 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,1445.72 2352.76,1445.72 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,1106.29 2352.76,1106.29 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,766.849 2352.76,766.849 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,427.413 2352.76,427.413 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  193.936,87.9763 2352.76,87.9763 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1486.45 193.936,47.2441 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1445.72 212.834,1445.72 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,1106.29 212.834,1106.29 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,766.849 212.834,766.849 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,427.413 212.834,427.413 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  193.936,87.9763 212.834,87.9763 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip560)\" d=\"M50.9921 1446.17 L80.6679 1446.17 L80.6679 1450.11 L50.9921 1450.11 L50.9921 1446.17 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M91.5706 1459.07 L99.2095 1459.07 L99.2095 1432.7 L90.8993 1434.37 L90.8993 1430.11 L99.1632 1428.44 L103.839 1428.44 L103.839 1459.07 L111.478 1459.07 L111.478 1463 L91.5706 1463 L91.5706 1459.07 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M120.922 1457.12 L125.807 1457.12 L125.807 1463 L120.922 1463 L120.922 1457.12 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M145.992 1431.52 Q142.381 1431.52 140.552 1435.09 Q138.746 1438.63 138.746 1445.76 Q138.746 1452.86 140.552 1456.43 Q142.381 1459.97 145.992 1459.97 Q149.626 1459.97 151.431 1456.43 Q153.26 1452.86 153.26 1445.76 Q153.26 1438.63 151.431 1435.09 Q149.626 1431.52 145.992 1431.52 M145.992 1427.82 Q151.802 1427.82 154.857 1432.42 Q157.936 1437.01 157.936 1445.76 Q157.936 1454.48 154.857 1459.09 Q151.802 1463.67 145.992 1463.67 Q140.181 1463.67 137.103 1459.09 Q134.047 1454.48 134.047 1445.76 Q134.047 1437.01 137.103 1432.42 Q140.181 1427.82 145.992 1427.82 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M51.9875 1106.74 L81.6633 1106.74 L81.6633 1110.67 L51.9875 1110.67 L51.9875 1106.74 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M101.756 1092.08 Q98.1447 1092.08 96.316 1095.65 Q94.5104 1099.19 94.5104 1106.32 Q94.5104 1113.43 96.316 1116.99 Q98.1447 1120.53 101.756 1120.53 Q105.39 1120.53 107.196 1116.99 Q109.024 1113.43 109.024 1106.32 Q109.024 1099.19 107.196 1095.65 Q105.39 1092.08 101.756 1092.08 M101.756 1088.38 Q107.566 1088.38 110.621 1092.99 Q113.7 1097.57 113.7 1106.32 Q113.7 1115.05 110.621 1119.65 Q107.566 1124.24 101.756 1124.24 Q95.9456 1124.24 92.8669 1119.65 Q89.8114 1115.05 89.8114 1106.32 Q89.8114 1097.57 92.8669 1092.99 Q95.9456 1088.38 101.756 1088.38 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M121.918 1117.69 L126.802 1117.69 L126.802 1123.57 L121.918 1123.57 L121.918 1117.69 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M137.033 1089.01 L155.39 1089.01 L155.39 1092.94 L141.316 1092.94 L141.316 1101.41 Q142.334 1101.07 143.353 1100.9 Q144.371 1100.72 145.39 1100.72 Q151.177 1100.72 154.556 1103.89 Q157.936 1107.06 157.936 1112.48 Q157.936 1118.06 154.464 1121.16 Q150.992 1124.24 144.672 1124.24 Q142.496 1124.24 140.228 1123.87 Q137.982 1123.5 135.575 1122.76 L135.575 1118.06 Q137.658 1119.19 139.881 1119.75 Q142.103 1120.3 144.58 1120.3 Q148.584 1120.3 150.922 1118.2 Q153.26 1116.09 153.26 1112.48 Q153.26 1108.87 150.922 1106.76 Q148.584 1104.65 144.58 1104.65 Q142.705 1104.65 140.83 1105.07 Q138.978 1105.49 137.033 1106.37 L137.033 1089.01 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M100.76 752.648 Q97.1493 752.648 95.3206 756.213 Q93.515 759.754 93.515 766.884 Q93.515 773.99 95.3206 777.555 Q97.1493 781.097 100.76 781.097 Q104.395 781.097 106.2 777.555 Q108.029 773.99 108.029 766.884 Q108.029 759.754 106.2 756.213 Q104.395 752.648 100.76 752.648 M100.76 748.944 Q106.571 748.944 109.626 753.551 Q112.705 758.134 112.705 766.884 Q112.705 775.611 109.626 780.217 Q106.571 784.801 100.76 784.801 Q94.9502 784.801 91.8715 780.217 Q88.816 775.611 88.816 766.884 Q88.816 758.134 91.8715 753.551 Q94.9502 748.944 100.76 748.944 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M120.922 778.25 L125.807 778.25 L125.807 784.129 L120.922 784.129 L120.922 778.25 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M145.992 752.648 Q142.381 752.648 140.552 756.213 Q138.746 759.754 138.746 766.884 Q138.746 773.99 140.552 777.555 Q142.381 781.097 145.992 781.097 Q149.626 781.097 151.431 777.555 Q153.26 773.99 153.26 766.884 Q153.26 759.754 151.431 756.213 Q149.626 752.648 145.992 752.648 M145.992 748.944 Q151.802 748.944 154.857 753.551 Q157.936 758.134 157.936 766.884 Q157.936 775.611 154.857 780.217 Q151.802 784.801 145.992 784.801 Q140.181 784.801 137.103 780.217 Q134.047 775.611 134.047 766.884 Q134.047 758.134 137.103 753.551 Q140.181 748.944 145.992 748.944 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M101.756 413.211 Q98.1447 413.211 96.316 416.776 Q94.5104 420.318 94.5104 427.448 Q94.5104 434.554 96.316 438.119 Q98.1447 441.66 101.756 441.66 Q105.39 441.66 107.196 438.119 Q109.024 434.554 109.024 427.448 Q109.024 420.318 107.196 416.776 Q105.39 413.211 101.756 413.211 M101.756 409.508 Q107.566 409.508 110.621 414.114 Q113.7 418.698 113.7 427.448 Q113.7 436.174 110.621 440.781 Q107.566 445.364 101.756 445.364 Q95.9456 445.364 92.8669 440.781 Q89.8114 436.174 89.8114 427.448 Q89.8114 418.698 92.8669 414.114 Q95.9456 409.508 101.756 409.508 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M121.918 438.813 L126.802 438.813 L126.802 444.693 L121.918 444.693 L121.918 438.813 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M137.033 410.133 L155.39 410.133 L155.39 414.068 L141.316 414.068 L141.316 422.54 Q142.334 422.193 143.353 422.031 Q144.371 421.846 145.39 421.846 Q151.177 421.846 154.556 425.017 Q157.936 428.188 157.936 433.605 Q157.936 439.184 154.464 442.285 Q150.992 445.364 144.672 445.364 Q142.496 445.364 140.228 444.994 Q137.982 444.623 135.575 443.883 L135.575 439.184 Q137.658 440.318 139.881 440.873 Q142.103 441.429 144.58 441.429 Q148.584 441.429 150.922 439.322 Q153.26 437.216 153.26 433.605 Q153.26 429.994 150.922 427.887 Q148.584 425.781 144.58 425.781 Q142.705 425.781 140.83 426.198 Q138.978 426.614 137.033 427.494 L137.033 410.133 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M91.5706 101.321 L99.2095 101.321 L99.2095 74.9555 L90.8993 76.6222 L90.8993 72.3629 L99.1632 70.6963 L103.839 70.6963 L103.839 101.321 L111.478 101.321 L111.478 105.256 L91.5706 105.256 L91.5706 101.321 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M120.922 99.3767 L125.807 99.3767 L125.807 105.256 L120.922 105.256 L120.922 99.3767 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M145.992 73.775 Q142.381 73.775 140.552 77.3398 Q138.746 80.8814 138.746 88.011 Q138.746 95.1174 140.552 98.6822 Q142.381 102.224 145.992 102.224 Q149.626 102.224 151.431 98.6822 Q153.26 95.1174 153.26 88.011 Q153.26 80.8814 151.431 77.3398 Q149.626 73.775 145.992 73.775 M145.992 70.0713 Q151.802 70.0713 154.857 74.6777 Q157.936 79.261 157.936 88.011 Q157.936 96.7378 154.857 101.344 Q151.802 105.928 145.992 105.928 Q140.181 105.928 137.103 101.344 Q134.047 96.7378 134.047 88.011 Q134.047 79.261 137.103 74.6777 Q140.181 70.0713 145.992 70.0713 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip562)\" style=\"stroke:#009af9; stroke-linecap:butt; stroke-linejoin:round; stroke-width:6; stroke-opacity:1; fill:none\" points=\"\n",
       "  255.035,766.849 265.218,699.075 275.401,631.978 285.584,566.229 295.767,502.484 305.95,441.38 316.133,383.529 326.316,329.507 336.5,279.856 346.683,235.07 \n",
       "  356.866,195.597 367.049,161.833 377.232,134.113 387.415,112.716 397.598,97.8541 407.781,89.6769 417.964,88.2657 428.148,93.6348 438.331,105.73 448.514,124.432 \n",
       "  458.697,149.552 468.88,180.84 479.063,217.983 489.246,260.61 499.429,308.296 509.612,360.563 519.796,416.889 529.979,476.713 540.162,539.435 550.345,604.429 \n",
       "  560.528,671.047 570.711,738.621 580.894,806.478 591.077,873.939 601.261,940.329 611.444,1004.99 621.627,1067.26 631.81,1126.54 641.993,1182.22 652.176,1233.76 \n",
       "  662.359,1280.62 672.542,1322.36 682.725,1358.54 692.909,1388.81 703.092,1412.87 713.275,1430.47 723.458,1441.44 733.641,1445.67 743.824,1443.12 754.007,1433.81 \n",
       "  764.19,1417.84 774.373,1395.36 784.557,1366.6 794.74,1331.85 804.923,1291.46 815.106,1245.82 825.289,1195.4 835.472,1140.69 845.655,1082.26 855.838,1020.66 \n",
       "  866.021,956.537 876.205,890.515 886.388,823.256 896.571,755.435 906.754,687.727 916.937,620.81 927.12,555.352 937.303,492.008 947.486,431.409 957.669,374.162 \n",
       "  967.853,320.839 978.036,271.972 988.219,228.05 998.402,189.511 1008.59,156.741 1018.77,130.066 1028.95,109.755 1039.13,96.0085 1049.32,88.9652 1059.5,88.695 \n",
       "  1069.68,95.2007 1079.87,108.417 1090.05,128.213 1100.23,154.389 1110.42,186.685 1120.6,224.778 1130.78,268.287 1140.97,316.777 1151.15,369.765 1161.33,426.72 \n",
       "  1171.51,487.073 1181.7,550.222 1191.88,615.535 1202.06,682.361 1212.25,750.03 1222.43,817.867 1232.61,885.195 1242.8,951.34 1252.98,1015.64 1263.16,1077.46 \n",
       "  1273.35,1136.17 1283.53,1191.19 1293.71,1241.98 1303.9,1288.01 1314.08,1328.84 1324.26,1364.05 1334.44,1393.3 1344.63,1416.28 1354.81,1432.78 1364.99,1442.62 \n",
       "  1375.18,1445.72 1385.36,1442.02 1395.54,1431.59 1405.73,1414.51 1415.91,1390.96 1426.09,1361.17 1436.28,1325.45 1446.46,1284.14 1456.64,1237.66 1466.83,1186.49 \n",
       "  1477.01,1131.11 1487.19,1072.1 1497.37,1010.04 1507.56,945.55 1517.74,879.274 1527.92,811.873 1538.11,744.024 1548.29,676.402 1558.47,609.684 1568.66,544.536 \n",
       "  1578.84,481.609 1589.02,421.533 1599.21,364.907 1609.39,312.296 1619.57,264.228 1629.75,221.182 1639.94,183.588 1650.12,151.821 1660.3,126.2 1670.49,106.98 \n",
       "  1680.67,94.3527 1690.85,88.4451 1701.04,89.3159 1711.22,96.9564 1721.4,111.29 1731.59,132.174 1741.77,159.4 1751.95,192.695 1762.14,231.726 1772.32,276.105 \n",
       "  1782.5,325.386 1792.68,379.079 1802.87,436.646 1813.05,497.513 1823.23,561.07 1833.42,626.684 1843.6,693.698 1853.78,761.443 1863.97,829.242 1874.15,896.418 \n",
       "  1884.33,962.299 1894.52,1026.23 1904.7,1087.56 1914.88,1145.7 1925.07,1200.04 1935.25,1250.06 1945.43,1295.25 1955.61,1335.16 1965.8,1369.39 1975.98,1397.61 \n",
       "  1986.16,1419.52 1996.35,1434.9 2006.53,1443.62 2016.71,1445.57 2026.9,1440.74 2037.08,1429.18 2047.26,1410.99 2057.45,1386.38 2067.63,1355.57 2077.81,1318.88 \n",
       "  2087.99,1276.67 2098.18,1229.37 2108.36,1177.45 2118.54,1121.43 2128.73,1061.86 2138.91,999.35 2149.09,934.513 2159.28,868.001 2169.46,800.478 2179.64,732.619 \n",
       "  2189.83,665.102 2200.01,598.601 2210.19,533.782 2220.38,471.292 2230.56,411.754 2240.74,355.765 2250.92,303.883 2261.11,256.626 2271.29,214.468 2281.47,177.829 \n",
       "  2291.66,147.075 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip562)\" style=\"stroke:#e26f46; stroke-linecap:butt; stroke-linejoin:round; stroke-width:6; stroke-opacity:1; fill:none\" stroke-dasharray=\"24, 15\" points=\"\n",
       "  255.035,87.9763 265.218,91.3678 275.401,101.509 285.584,118.297 295.767,141.566 305.95,171.082 316.133,206.551 326.316,247.619 336.5,293.874 346.683,344.855 \n",
       "  356.866,400.053 367.049,458.915 377.232,520.854 387.415,585.252 397.598,651.463 407.781,718.828 417.964,786.672 428.148,854.318 438.331,921.091 448.514,986.322 \n",
       "  458.697,1049.36 468.88,1109.58 479.063,1166.37 489.246,1219.17 499.429,1267.45 509.612,1310.72 519.796,1348.57 529.979,1380.6 540.162,1406.5 550.345,1426.01 \n",
       "  560.528,1438.93 570.711,1445.14 580.894,1444.56 591.077,1437.22 601.261,1423.18 611.444,1402.58 621.627,1375.63 631.81,1342.6 641.993,1303.82 652.176,1259.67 \n",
       "  662.359,1210.59 672.542,1157.08 682.725,1099.67 692.909,1038.94 703.092,975.489 713.275,909.953 723.458,842.987 733.641,775.26 743.824,707.449 754.007,640.231 \n",
       "  764.19,574.279 774.373,510.25 784.557,448.786 794.74,390.5 804.923,335.973 815.106,285.753 825.289,240.339 835.472,200.185 845.655,165.694 855.838,137.209 \n",
       "  866.021,115.016 876.205,99.3349 886.388,90.3238 896.571,88.0722 906.754,92.6029 916.937,103.87 927.12,121.762 937.303,146.099 947.486,176.639 957.669,213.076 \n",
       "  967.853,255.045 978.036,302.129 988.219,353.856 998.402,409.709 1008.59,469.131 1018.77,531.528 1028.95,596.276 1039.13,662.728 1049.32,730.22 1059.5,798.079 \n",
       "  1069.68,865.625 1079.87,932.185 1090.05,997.092 1100.23,1059.7 1110.42,1119.38 1120.6,1175.54 1130.78,1227.61 1140.97,1275.09 1151.15,1317.48 1161.33,1354.37 \n",
       "  1171.51,1385.39 1181.7,1410.23 1191.88,1428.64 1202.06,1440.44 1212.25,1445.51 1222.43,1443.8 1232.61,1435.33 1242.8,1420.17 1252.98,1398.49 1263.16,1370.5 \n",
       "  1273.35,1336.47 1283.53,1296.76 1293.71,1251.74 1303.9,1201.89 1314.08,1147.69 1324.26,1089.68 1334.44,1028.45 1344.63,964.598 1354.81,898.775 1364.99,831.633 \n",
       "  1375.18,763.845 1385.36,696.086 1395.54,629.035 1405.73,563.36 1415.91,499.719 1426.09,438.747 1436.28,381.053 1446.46,327.214 1456.64,277.767 1466.83,233.207 \n",
       "  1477.01,193.98 1487.19,160.476 1497.37,133.031 1507.56,111.918 1517.74,97.35 1527.92,89.471 1538.11,88.3601 1548.29,94.0285 1558.47,106.42 1568.66,125.409 \n",
       "  1578.84,150.808 1589.02,182.362 1599.21,219.756 1609.39,262.617 1619.57,310.516 1629.75,362.974 1639.94,419.467 1650.12,479.432 1660.3,542.268 1670.49,607.348 \n",
       "  1680.67,674.022 1690.85,741.623 1701.04,809.477 1711.22,876.904 1721.4,943.232 1731.59,1007.8 1741.77,1069.96 1751.95,1129.09 1762.14,1184.6 1772.32,1235.93 \n",
       "  1782.5,1282.58 1792.68,1324.08 1802.87,1360.01 1813.05,1390.01 1823.23,1413.78 1833.42,1431.09 1843.6,1441.77 1853.78,1445.7 1863.97,1442.85 1874.15,1433.24 \n",
       "  1884.33,1416.98 1894.52,1394.22 1904.7,1365.19 1914.88,1330.18 1925.07,1289.55 1935.25,1243.69 1945.43,1193.06 1955.61,1138.18 1965.8,1079.59 1975.98,1017.88 \n",
       "  1986.16,953.65 1996.35,887.559 2006.53,820.262 2016.71,752.431 2026.9,684.744 2037.08,617.877 2047.26,552.499 2057.45,489.263 2067.63,428.8 2077.81,371.715 \n",
       "  2087.99,318.578 2098.18,269.92 2108.36,226.227 2118.54,187.936 2128.73,155.429 2138.91,129.031 2149.09,109.006 2159.28,95.5543 2169.46,88.8097 2179.64,88.8398 \n",
       "  2189.83,95.6444 2200.01,109.155 2210.19,129.238 2220.38,155.691 2230.56,188.251 2240.74,226.592 2250.92,270.331 2261.11,319.031 2271.29,372.206 2281.47,429.323 \n",
       "  2291.66,489.813 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip560)\" d=\"\n",
       "M1988.36 250.738 L2280.8 250.738 L2280.8 95.2176 L1988.36 95.2176  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1988.36,250.738 2280.8,250.738 2280.8,95.2176 1988.36,95.2176 1988.36,250.738 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip560)\" style=\"stroke:#009af9; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2012.36,147.058 2156.36,147.058 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip560)\" d=\"M2194.21 166.745 Q2192.4 171.375 2190.69 172.787 Q2188.98 174.199 2186.11 174.199 L2182.7 174.199 L2182.7 170.634 L2185.2 170.634 Q2186.96 170.634 2187.93 169.8 Q2188.91 168.967 2190.09 165.865 L2190.85 163.921 L2180.36 138.412 L2184.88 138.412 L2192.98 158.689 L2201.08 138.412 L2205.6 138.412 L2194.21 166.745 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M2212.89 160.402 L2220.53 160.402 L2220.53 134.037 L2212.22 135.703 L2212.22 131.444 L2220.48 129.778 L2225.16 129.778 L2225.16 160.402 L2232.8 160.402 L2232.8 164.338 L2212.89 164.338 L2212.89 160.402 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip560)\" style=\"stroke:#e26f46; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" stroke-dasharray=\"16, 10\" points=\"\n",
       "  2012.36,198.898 2156.36,198.898 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip560)\" d=\"M2194.21 218.585 Q2192.4 223.215 2190.69 224.627 Q2188.98 226.039 2186.11 226.039 L2182.7 226.039 L2182.7 222.474 L2185.2 222.474 Q2186.96 222.474 2187.93 221.64 Q2188.91 220.807 2190.09 217.705 L2190.85 215.761 L2180.36 190.252 L2184.88 190.252 L2192.98 210.529 L2201.08 190.252 L2205.6 190.252 L2194.21 218.585 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip560)\" d=\"M2216.11 212.242 L2232.42 212.242 L2232.42 216.178 L2210.48 216.178 L2210.48 212.242 Q2213.14 209.488 2217.73 204.858 Q2222.33 200.205 2223.51 198.863 Q2225.76 196.34 2226.64 194.604 Q2227.54 192.844 2227.54 191.155 Q2227.54 188.4 2225.6 186.664 Q2223.67 184.928 2220.57 184.928 Q2218.37 184.928 2215.92 185.692 Q2213.49 186.455 2210.71 188.006 L2210.71 183.284 Q2213.54 182.15 2215.99 181.571 Q2218.44 180.993 2220.48 180.993 Q2225.85 180.993 2229.05 183.678 Q2232.24 186.363 2232.24 190.854 Q2232.24 192.983 2231.43 194.905 Q2230.64 196.803 2228.54 199.395 Q2227.96 200.067 2224.86 203.284 Q2221.75 206.479 2216.11 212.242 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /></svg>\n"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(xs, ys_1, lw = 1.5, ls = :solid)\n",
    "plot!(xs, ys_2, lw = 1.5, ls = :dash)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets look at a more complex plotting example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.0:0.06060606060606061:5.96969696969697"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = -3:6/99:6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "function fn1(x) #define a new function to plot \n",
    "    y = (x-1.1)^2 - 0.5\n",
    "    return y\n",
    "  end; "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"600\" height=\"400\" viewBox=\"0 0 2400 1600\">\n",
       "<defs>\n",
       "  <clipPath id=\"clip600\">\n",
       "    <rect x=\"0\" y=\"0\" width=\"2400\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<path clip-path=\"url(#clip600)\" d=\"\n",
       "M0 1600 L2400 1600 L2400 0 L0 0  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip601\">\n",
       "    <rect x=\"480\" y=\"0\" width=\"1681\" height=\"1600\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<path clip-path=\"url(#clip600)\" d=\"\n",
       "M203.964 1423.18 L2352.76 1423.18 L2352.76 123.472 L203.964 123.472  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<defs>\n",
       "  <clipPath id=\"clip602\">\n",
       "    <rect x=\"203\" y=\"123\" width=\"2150\" height=\"1301\"/>\n",
       "  </clipPath>\n",
       "</defs>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  490.78,1423.18 490.78,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  942.782,1423.18 942.782,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1394.78,1423.18 1394.78,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  1846.79,1423.18 1846.79,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  2298.79,1423.18 2298.79,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  203.964,1423.18 2352.76,1423.18 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  490.78,1423.18 490.78,1404.28 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  942.782,1423.18 942.782,1404.28 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1394.78,1423.18 1394.78,1404.28 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1846.79,1423.18 1846.79,1404.28 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  2298.79,1423.18 2298.79,1404.28 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip600)\" d=\"M460.722 1468.75 L490.398 1468.75 L490.398 1472.69 L460.722 1472.69 L460.722 1468.75 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M504.518 1481.64 L520.837 1481.64 L520.837 1485.58 L498.893 1485.58 L498.893 1481.64 Q501.555 1478.89 506.138 1474.26 Q510.745 1469.61 511.925 1468.27 Q514.171 1465.74 515.05 1464.01 Q515.953 1462.25 515.953 1460.56 Q515.953 1457.8 514.009 1456.07 Q512.087 1454.33 508.986 1454.33 Q506.787 1454.33 504.333 1455.09 Q501.902 1455.86 499.125 1457.41 L499.125 1452.69 Q501.949 1451.55 504.402 1450.97 Q506.856 1450.39 508.893 1450.39 Q514.263 1450.39 517.458 1453.08 Q520.652 1455.77 520.652 1460.26 Q520.652 1462.39 519.842 1464.31 Q519.055 1466.2 516.949 1468.8 Q516.37 1469.47 513.268 1472.69 Q510.166 1475.88 504.518 1481.64 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M942.782 1454.1 Q939.171 1454.1 937.342 1457.66 Q935.537 1461.2 935.537 1468.33 Q935.537 1475.44 937.342 1479.01 Q939.171 1482.55 942.782 1482.55 Q946.416 1482.55 948.222 1479.01 Q950.051 1475.44 950.051 1468.33 Q950.051 1461.2 948.222 1457.66 Q946.416 1454.1 942.782 1454.1 M942.782 1450.39 Q948.592 1450.39 951.648 1455 Q954.727 1459.58 954.727 1468.33 Q954.727 1477.06 951.648 1481.67 Q948.592 1486.25 942.782 1486.25 Q936.972 1486.25 933.893 1481.67 Q930.838 1477.06 930.838 1468.33 Q930.838 1459.58 933.893 1455 Q936.972 1450.39 942.782 1450.39 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1389.44 1481.64 L1405.76 1481.64 L1405.76 1485.58 L1383.81 1485.58 L1383.81 1481.64 Q1386.47 1478.89 1391.06 1474.26 Q1395.66 1469.61 1396.84 1468.27 Q1399.09 1465.74 1399.97 1464.01 Q1400.87 1462.25 1400.87 1460.56 Q1400.87 1457.8 1398.93 1456.07 Q1397.01 1454.33 1393.9 1454.33 Q1391.71 1454.33 1389.25 1455.09 Q1386.82 1455.86 1384.04 1457.41 L1384.04 1452.69 Q1386.87 1451.55 1389.32 1450.97 Q1391.78 1450.39 1393.81 1450.39 Q1399.18 1450.39 1402.38 1453.08 Q1405.57 1455.77 1405.57 1460.26 Q1405.57 1462.39 1404.76 1464.31 Q1403.97 1466.2 1401.87 1468.8 Q1401.29 1469.47 1398.19 1472.69 Q1395.09 1475.88 1389.44 1481.64 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1849.8 1455.09 L1837.99 1473.54 L1849.8 1473.54 L1849.8 1455.09 M1848.57 1451.02 L1854.45 1451.02 L1854.45 1473.54 L1859.38 1473.54 L1859.38 1477.43 L1854.45 1477.43 L1854.45 1485.58 L1849.8 1485.58 L1849.8 1477.43 L1834.19 1477.43 L1834.19 1472.92 L1848.57 1451.02 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M2299.19 1466.44 Q2296.05 1466.44 2294.19 1468.59 Q2292.37 1470.74 2292.37 1474.49 Q2292.37 1478.22 2294.19 1480.39 Q2296.05 1482.55 2299.19 1482.55 Q2302.34 1482.55 2304.17 1480.39 Q2306.02 1478.22 2306.02 1474.49 Q2306.02 1470.74 2304.17 1468.59 Q2302.34 1466.44 2299.19 1466.44 M2308.48 1451.78 L2308.48 1456.04 Q2306.72 1455.21 2304.91 1454.77 Q2303.13 1454.33 2301.37 1454.33 Q2296.74 1454.33 2294.29 1457.45 Q2291.86 1460.58 2291.51 1466.9 Q2292.88 1464.89 2294.94 1463.82 Q2297 1462.73 2299.47 1462.73 Q2304.68 1462.73 2307.69 1465.9 Q2310.72 1469.05 2310.72 1474.49 Q2310.72 1479.82 2307.57 1483.03 Q2304.43 1486.25 2299.19 1486.25 Q2293.2 1486.25 2290.03 1481.67 Q2286.86 1477.06 2286.86 1468.33 Q2286.86 1460.14 2290.75 1455.28 Q2294.63 1450.39 2301.19 1450.39 Q2302.94 1450.39 2304.73 1450.74 Q2306.53 1451.09 2308.48 1451.78 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1099.52 1520.52 L1105.94 1520.52 L1105.94 1568.04 L1099.52 1568.04 L1099.52 1520.52 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1148.12 1546.53 L1148.12 1568.04 L1142.26 1568.04 L1142.26 1546.72 Q1142.26 1541.66 1140.29 1539.14 Q1138.31 1536.63 1134.37 1536.63 Q1129.63 1536.63 1126.89 1539.65 Q1124.15 1542.68 1124.15 1547.9 L1124.15 1568.04 L1118.26 1568.04 L1118.26 1532.4 L1124.15 1532.4 L1124.15 1537.93 Q1126.25 1534.72 1129.08 1533.13 Q1131.95 1531.54 1135.67 1531.54 Q1141.82 1531.54 1144.97 1535.36 Q1148.12 1539.14 1148.12 1546.53 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1165.46 1562.7 L1165.46 1581.6 L1159.58 1581.6 L1159.58 1532.4 L1165.46 1532.4 L1165.46 1537.81 Q1167.31 1534.62 1170.11 1533.1 Q1172.94 1531.54 1176.86 1531.54 Q1183.35 1531.54 1187.39 1536.69 Q1191.47 1541.85 1191.47 1550.25 Q1191.47 1558.65 1187.39 1563.81 Q1183.35 1568.97 1176.86 1568.97 Q1172.94 1568.97 1170.11 1567.44 Q1167.31 1565.88 1165.46 1562.7 M1185.39 1550.25 Q1185.39 1543.79 1182.71 1540.13 Q1180.07 1536.44 1175.43 1536.44 Q1170.78 1536.44 1168.11 1540.13 Q1165.46 1543.79 1165.46 1550.25 Q1165.46 1556.71 1168.11 1560.4 Q1170.78 1564.07 1175.43 1564.07 Q1180.07 1564.07 1182.71 1560.4 Q1185.39 1556.71 1185.39 1550.25 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1200.57 1553.98 L1200.57 1532.4 L1206.43 1532.4 L1206.43 1553.75 Q1206.43 1558.81 1208.4 1561.36 Q1210.37 1563.87 1214.32 1563.87 Q1219.06 1563.87 1221.8 1560.85 Q1224.57 1557.83 1224.57 1552.61 L1224.57 1532.4 L1230.43 1532.4 L1230.43 1568.04 L1224.57 1568.04 L1224.57 1562.57 Q1222.44 1565.82 1219.6 1567.41 Q1216.8 1568.97 1213.08 1568.97 Q1206.94 1568.97 1203.75 1565.15 Q1200.57 1561.33 1200.57 1553.98 M1215.31 1531.54 L1215.31 1531.54 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1248.28 1522.27 L1248.28 1532.4 L1260.34 1532.4 L1260.34 1536.95 L1248.28 1536.95 L1248.28 1556.3 Q1248.28 1560.66 1249.46 1561.9 Q1250.67 1563.14 1254.33 1563.14 L1260.34 1563.14 L1260.34 1568.04 L1254.33 1568.04 Q1247.55 1568.04 1244.97 1565.53 Q1242.39 1562.98 1242.39 1556.3 L1242.39 1536.95 L1238.1 1536.95 L1238.1 1532.4 L1242.39 1532.4 L1242.39 1522.27 L1248.28 1522.27 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1284.57 1532.4 L1290.77 1532.4 L1301.91 1562.31 L1313.05 1532.4 L1319.26 1532.4 L1305.89 1568.04 L1297.93 1568.04 L1284.57 1532.4 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1343.54 1550.12 Q1336.45 1550.12 1333.71 1551.75 Q1330.97 1553.37 1330.97 1557.29 Q1330.97 1560.4 1333.01 1562.25 Q1335.08 1564.07 1338.61 1564.07 Q1343.48 1564.07 1346.41 1560.63 Q1349.37 1557.16 1349.37 1551.43 L1349.37 1550.12 L1343.54 1550.12 M1355.23 1547.71 L1355.23 1568.04 L1349.37 1568.04 L1349.37 1562.63 Q1347.36 1565.88 1344.37 1567.44 Q1341.38 1568.97 1337.05 1568.97 Q1331.58 1568.97 1328.33 1565.91 Q1325.12 1562.82 1325.12 1557.67 Q1325.12 1551.65 1329.13 1548.6 Q1333.17 1545.54 1341.16 1545.54 L1349.37 1545.54 L1349.37 1544.97 Q1349.37 1540.93 1346.7 1538.73 Q1344.05 1536.5 1339.25 1536.5 Q1336.19 1536.5 1333.3 1537.23 Q1330.4 1537.97 1327.73 1539.43 L1327.73 1534.02 Q1330.94 1532.78 1333.96 1532.17 Q1336.99 1531.54 1339.85 1531.54 Q1347.59 1531.54 1351.41 1535.55 Q1355.23 1539.56 1355.23 1547.71 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1367.29 1518.52 L1373.15 1518.52 L1373.15 1568.04 L1367.29 1568.04 L1367.29 1518.52 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1384.79 1553.98 L1384.79 1532.4 L1390.65 1532.4 L1390.65 1553.75 Q1390.65 1558.81 1392.62 1561.36 Q1394.6 1563.87 1398.54 1563.87 Q1403.29 1563.87 1406.02 1560.85 Q1408.79 1557.83 1408.79 1552.61 L1408.79 1532.4 L1414.65 1532.4 L1414.65 1568.04 L1408.79 1568.04 L1408.79 1562.57 Q1406.66 1565.82 1403.83 1567.41 Q1401.03 1568.97 1397.3 1568.97 Q1391.16 1568.97 1387.98 1565.15 Q1384.79 1561.33 1384.79 1553.98 M1399.53 1531.54 L1399.53 1531.54 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1457.2 1548.76 L1457.2 1551.62 L1430.28 1551.62 Q1430.66 1557.67 1433.91 1560.85 Q1437.18 1564 1443.01 1564 Q1446.38 1564 1449.53 1563.17 Q1452.72 1562.35 1455.84 1560.69 L1455.84 1566.23 Q1452.68 1567.57 1449.37 1568.27 Q1446.06 1568.97 1442.66 1568.97 Q1434.13 1568.97 1429.13 1564 Q1424.17 1559.04 1424.17 1550.57 Q1424.17 1541.82 1428.88 1536.69 Q1433.62 1531.54 1441.64 1531.54 Q1448.83 1531.54 1453 1536.18 Q1457.2 1540.8 1457.2 1548.76 M1451.35 1547.04 Q1451.28 1542.23 1448.64 1539.37 Q1446.03 1536.5 1441.7 1536.5 Q1436.8 1536.5 1433.84 1539.27 Q1430.91 1542.04 1430.47 1547.07 L1451.35 1547.04 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  203.964,1335.77 2352.76,1335.77 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  203.964,1082.58 2352.76,1082.58 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  203.964,829.386 2352.76,829.386 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  203.964,576.196 2352.76,576.196 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:2; stroke-opacity:0.1; fill:none\" points=\"\n",
       "  203.964,323.005 2352.76,323.005 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  203.964,1423.18 203.964,123.472 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  203.964,1335.77 222.861,1335.77 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  203.964,1082.58 222.861,1082.58 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  203.964,829.386 222.861,829.386 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  203.964,576.196 222.861,576.196 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  203.964,323.005 222.861,323.005 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip600)\" d=\"M156.019 1321.57 Q152.408 1321.57 150.579 1325.13 Q148.774 1328.67 148.774 1335.8 Q148.774 1342.91 150.579 1346.47 Q152.408 1350.02 156.019 1350.02 Q159.653 1350.02 161.459 1346.47 Q163.288 1342.91 163.288 1335.8 Q163.288 1328.67 161.459 1325.13 Q159.653 1321.57 156.019 1321.57 M156.019 1317.86 Q161.829 1317.86 164.885 1322.47 Q167.964 1327.05 167.964 1335.8 Q167.964 1344.53 164.885 1349.14 Q161.829 1353.72 156.019 1353.72 Q150.209 1353.72 147.13 1349.14 Q144.075 1344.53 144.075 1335.8 Q144.075 1327.05 147.13 1322.47 Q150.209 1317.86 156.019 1317.86 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M147.061 1065.3 L165.417 1065.3 L165.417 1069.23 L151.343 1069.23 L151.343 1077.7 Q152.362 1077.36 153.38 1077.2 Q154.399 1077.01 155.417 1077.01 Q161.204 1077.01 164.584 1080.18 Q167.964 1083.35 167.964 1088.77 Q167.964 1094.35 164.491 1097.45 Q161.019 1100.53 154.7 1100.53 Q152.524 1100.53 150.255 1100.16 Q148.01 1099.79 145.603 1099.05 L145.603 1094.35 Q147.686 1095.48 149.908 1096.04 Q152.13 1096.59 154.607 1096.59 Q158.612 1096.59 160.95 1094.49 Q163.288 1092.38 163.288 1088.77 Q163.288 1085.16 160.95 1083.05 Q158.612 1080.95 154.607 1080.95 Q152.732 1080.95 150.857 1081.36 Q149.005 1081.78 147.061 1082.66 L147.061 1065.3 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M116.668 842.731 L124.306 842.731 L124.306 816.366 L115.996 818.032 L115.996 813.773 L124.26 812.106 L128.936 812.106 L128.936 842.731 L136.575 842.731 L136.575 846.666 L116.668 846.666 L116.668 842.731 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M156.019 815.185 Q152.408 815.185 150.579 818.75 Q148.774 822.292 148.774 829.421 Q148.774 836.528 150.579 840.092 Q152.408 843.634 156.019 843.634 Q159.653 843.634 161.459 840.092 Q163.288 836.528 163.288 829.421 Q163.288 822.292 161.459 818.75 Q159.653 815.185 156.019 815.185 M156.019 811.481 Q161.829 811.481 164.885 816.088 Q167.964 820.671 167.964 829.421 Q167.964 838.148 164.885 842.754 Q161.829 847.338 156.019 847.338 Q150.209 847.338 147.13 842.754 Q144.075 838.148 144.075 829.421 Q144.075 820.671 147.13 816.088 Q150.209 811.481 156.019 811.481 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M117.663 589.54 L125.302 589.54 L125.302 563.175 L116.992 564.841 L116.992 560.582 L125.255 558.916 L129.931 558.916 L129.931 589.54 L137.57 589.54 L137.57 593.476 L117.663 593.476 L117.663 589.54 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M147.061 558.916 L165.417 558.916 L165.417 562.851 L151.343 562.851 L151.343 571.323 Q152.362 570.976 153.38 570.814 Q154.399 570.628 155.417 570.628 Q161.204 570.628 164.584 573.8 Q167.964 576.971 167.964 582.388 Q167.964 587.966 164.491 591.068 Q161.019 594.147 154.7 594.147 Q152.524 594.147 150.255 593.776 Q148.01 593.406 145.603 592.665 L145.603 587.966 Q147.686 589.101 149.908 589.656 Q152.13 590.212 154.607 590.212 Q158.612 590.212 160.95 588.105 Q163.288 585.999 163.288 582.388 Q163.288 578.777 160.95 576.67 Q158.612 574.564 154.607 574.564 Q152.732 574.564 150.857 574.98 Q149.005 575.397 147.061 576.277 L147.061 558.916 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M119.885 336.35 L136.204 336.35 L136.204 340.285 L114.26 340.285 L114.26 336.35 Q116.922 333.595 121.505 328.965 Q126.112 324.313 127.292 322.97 Q129.538 320.447 130.417 318.711 Q131.32 316.952 131.32 315.262 Q131.32 312.507 129.376 310.771 Q127.455 309.035 124.353 309.035 Q122.154 309.035 119.7 309.799 Q117.269 310.563 114.492 312.114 L114.492 307.391 Q117.316 306.257 119.769 305.678 Q122.223 305.1 124.26 305.1 Q129.63 305.1 132.825 307.785 Q136.019 310.47 136.019 314.961 Q136.019 317.09 135.209 319.012 Q134.422 320.91 132.316 323.502 Q131.737 324.174 128.635 327.391 Q125.533 330.586 119.885 336.35 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M156.019 308.803 Q152.408 308.803 150.579 312.368 Q148.774 315.91 148.774 323.039 Q148.774 330.146 150.579 333.711 Q152.408 337.252 156.019 337.252 Q159.653 337.252 161.459 333.711 Q163.288 330.146 163.288 323.039 Q163.288 315.91 161.459 312.368 Q159.653 308.803 156.019 308.803 M156.019 305.1 Q161.829 305.1 164.885 309.706 Q167.964 314.29 167.964 323.039 Q167.964 331.766 164.885 336.373 Q161.829 340.956 156.019 340.956 Q150.209 340.956 147.13 336.373 Q144.075 331.766 144.075 323.039 Q144.075 314.29 147.13 309.706 Q150.209 305.1 156.019 305.1 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M20.8447 960.335 Q20.8447 967.337 26.0645 971.475 Q31.2844 975.58 40.2919 975.58 Q49.2675 975.58 54.4874 971.475 Q59.7073 967.337 59.7073 960.335 Q59.7073 953.332 54.4874 949.258 Q49.2675 945.152 40.2919 945.152 Q31.2844 945.152 26.0645 949.258 Q20.8447 953.332 20.8447 960.335 M15.6248 960.335 Q15.6248 950.34 22.3406 944.357 Q29.0246 938.373 40.2919 938.373 Q51.5274 938.373 58.2432 944.357 Q64.9272 950.34 64.9272 960.335 Q64.9272 970.361 58.2432 976.376 Q51.5592 982.36 40.2919 982.36 Q29.0246 982.36 22.3406 976.376 Q15.6248 970.361 15.6248 960.335 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M49.9359 929.174 L28.3562 929.174 L28.3562 923.318 L49.7131 923.318 Q54.7739 923.318 57.3202 921.345 Q59.8346 919.371 59.8346 915.424 Q59.8346 910.682 56.8109 907.945 Q53.7872 905.176 48.5673 905.176 L28.3562 905.176 L28.3562 899.319 L64.0042 899.319 L64.0042 905.176 L58.5296 905.176 Q61.7762 907.308 63.3676 910.141 Q64.9272 912.942 64.9272 916.666 Q64.9272 922.809 61.1078 925.992 Q57.2883 929.174 49.9359 929.174 M27.4968 914.438 L27.4968 914.438 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M18.2347 881.463 L28.3562 881.463 L28.3562 869.4 L32.9077 869.4 L32.9077 881.463 L52.2594 881.463 Q56.6199 881.463 57.8613 880.286 Q59.1026 879.076 59.1026 875.416 L59.1026 869.4 L64.0042 869.4 L64.0042 875.416 Q64.0042 882.195 61.4897 884.774 Q58.9434 887.352 52.2594 887.352 L32.9077 887.352 L32.9077 891.649 L28.3562 891.649 L28.3562 887.352 L18.2347 887.352 L18.2347 881.463 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M58.657 856.032 L77.5631 856.032 L77.5631 861.921 L28.3562 861.921 L28.3562 856.032 L33.7671 856.032 Q30.5842 854.186 29.0564 851.385 Q27.4968 848.553 27.4968 844.638 Q27.4968 838.145 32.6531 834.103 Q37.8093 830.029 46.212 830.029 Q54.6147 830.029 59.771 834.103 Q64.9272 838.145 64.9272 844.638 Q64.9272 848.553 63.3994 851.385 Q61.8398 854.186 58.657 856.032 M46.212 836.108 Q39.7508 836.108 36.0905 838.781 Q32.3984 841.423 32.3984 846.07 Q32.3984 850.717 36.0905 853.391 Q39.7508 856.032 46.212 856.032 Q52.6732 856.032 56.3653 853.391 Q60.0256 850.717 60.0256 846.07 Q60.0256 841.423 56.3653 838.781 Q52.6732 836.108 46.212 836.108 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M49.9359 820.926 L28.3562 820.926 L28.3562 815.069 L49.7131 815.069 Q54.7739 815.069 57.3202 813.096 Q59.8346 811.122 59.8346 807.176 Q59.8346 802.433 56.8109 799.696 Q53.7872 796.927 48.5673 796.927 L28.3562 796.927 L28.3562 791.07 L64.0042 791.07 L64.0042 796.927 L58.5296 796.927 Q61.7762 799.059 63.3676 801.892 Q64.9272 804.693 64.9272 808.417 Q64.9272 814.56 61.1078 817.743 Q57.2883 820.926 49.9359 820.926 M27.4968 806.189 L27.4968 806.189 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M18.2347 773.215 L28.3562 773.215 L28.3562 761.152 L32.9077 761.152 L32.9077 773.215 L52.2594 773.215 Q56.6199 773.215 57.8613 772.037 Q59.1026 770.827 59.1026 767.167 L59.1026 761.152 L64.0042 761.152 L64.0042 767.167 Q64.0042 773.947 61.4897 776.525 Q58.9434 779.103 52.2594 779.103 L32.9077 779.103 L32.9077 783.4 L28.3562 783.4 L28.3562 779.103 L18.2347 779.103 L18.2347 773.215 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M28.3562 736.93 L28.3562 730.723 L58.275 719.584 L28.3562 708.444 L28.3562 702.237 L64.0042 715.605 L64.0042 723.562 L28.3562 736.93 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M46.0847 677.952 Q46.0847 685.05 47.7079 687.787 Q49.3312 690.524 53.2461 690.524 Q56.3653 690.524 58.2114 688.487 Q60.0256 686.418 60.0256 682.885 Q60.0256 678.015 56.5881 675.087 Q53.1188 672.127 47.3897 672.127 L46.0847 672.127 L46.0847 677.952 M43.6657 666.271 L64.0042 666.271 L64.0042 672.127 L58.5933 672.127 Q61.8398 674.132 63.3994 677.124 Q64.9272 680.116 64.9272 684.445 Q64.9272 689.919 61.8716 693.166 Q58.7843 696.381 53.6281 696.381 Q47.6125 696.381 44.5569 692.37 Q41.5014 688.328 41.5014 680.339 L41.5014 672.127 L40.9285 672.127 Q36.8862 672.127 34.6901 674.801 Q32.4621 677.443 32.4621 682.249 Q32.4621 685.304 33.1941 688.201 Q33.9262 691.097 35.3903 693.771 L29.9795 693.771 Q28.7381 690.556 28.1334 687.532 Q27.4968 684.508 27.4968 681.644 Q27.4968 673.91 31.5072 670.09 Q35.5176 666.271 43.6657 666.271 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M14.479 654.208 L14.479 648.351 L64.0042 648.351 L64.0042 654.208 L14.479 654.208 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M49.9359 636.702 L28.3562 636.702 L28.3562 630.846 L49.7131 630.846 Q54.7739 630.846 57.3202 628.872 Q59.8346 626.899 59.8346 622.952 Q59.8346 618.21 56.8109 615.472 Q53.7872 612.703 48.5673 612.703 L28.3562 612.703 L28.3562 606.847 L64.0042 606.847 L64.0042 612.703 L58.5296 612.703 Q61.7762 614.836 63.3676 617.669 Q64.9272 620.469 64.9272 624.193 Q64.9272 630.336 61.1078 633.519 Q57.2883 636.702 49.9359 636.702 M27.4968 621.965 L27.4968 621.965 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M44.7161 564.292 L47.5806 564.292 L47.5806 591.219 Q53.6281 590.837 56.8109 587.591 Q59.9619 584.312 59.9619 578.488 Q59.9619 575.114 59.1344 571.963 Q58.3069 568.78 56.6518 565.661 L62.1899 565.661 Q63.5267 568.812 64.227 572.122 Q64.9272 575.432 64.9272 578.838 Q64.9272 587.368 59.9619 592.365 Q54.9967 597.33 46.5303 597.33 Q37.7774 597.33 32.6531 592.619 Q27.4968 587.877 27.4968 579.856 Q27.4968 572.663 32.1438 568.493 Q36.7589 564.292 44.7161 564.292 M42.9973 570.149 Q38.1912 570.212 35.3266 572.854 Q32.4621 575.464 32.4621 579.793 Q32.4621 584.694 35.2312 587.654 Q38.0002 590.582 43.0292 591.028 L42.9973 570.149 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M977.297 16.7545 L977.297 25.383 Q973.165 21.5346 968.466 19.6307 Q963.807 17.7268 958.541 17.7268 Q948.171 17.7268 942.661 24.0867 Q937.152 30.4061 937.152 42.3968 Q937.152 54.3469 942.661 60.7069 Q948.171 67.0263 958.541 67.0263 Q963.807 67.0263 968.466 65.1223 Q973.165 63.2184 977.297 59.3701 L977.297 67.9175 Q973.003 70.8341 968.182 72.2924 Q963.402 73.7508 958.055 73.7508 Q944.322 73.7508 936.423 65.3654 Q928.524 56.9395 928.524 42.3968 Q928.524 27.8135 936.423 19.4281 Q944.322 11.0023 958.055 11.0023 Q963.483 11.0023 968.263 12.4606 Q973.084 13.8784 977.297 16.7545 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1007.19 32.4315 Q1001.2 32.4315 997.713 37.1306 Q994.229 41.7891 994.229 49.9314 Q994.229 58.0738 997.673 62.7728 Q1001.16 67.4314 1007.19 67.4314 Q1013.15 67.4314 1016.63 62.7323 Q1020.11 58.0333 1020.11 49.9314 Q1020.11 41.8701 1016.63 37.1711 Q1013.15 32.4315 1007.19 32.4315 M1007.19 26.1121 Q1016.91 26.1121 1022.46 32.4315 Q1028.01 38.7509 1028.01 49.9314 Q1028.01 61.0714 1022.46 67.4314 Q1016.91 73.7508 1007.19 73.7508 Q997.43 73.7508 991.88 67.4314 Q986.371 61.0714 986.371 49.9314 Q986.371 38.7509 991.88 32.4315 Q997.43 26.1121 1007.19 26.1121 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1075.69 35.9153 Q1078.49 30.8922 1082.38 28.5022 Q1086.27 26.1121 1091.53 26.1121 Q1098.62 26.1121 1102.47 31.0947 Q1106.32 36.0368 1106.32 45.1919 L1106.32 72.576 L1098.82 72.576 L1098.82 45.4349 Q1098.82 38.913 1096.51 35.7533 Q1094.21 32.5936 1089.47 32.5936 Q1083.67 32.5936 1080.31 36.4419 Q1076.95 40.2903 1076.95 46.9338 L1076.95 72.576 L1069.45 72.576 L1069.45 45.4349 Q1069.45 38.8725 1067.15 35.7533 Q1064.84 32.5936 1060.02 32.5936 Q1054.3 32.5936 1050.94 36.4824 Q1047.58 40.3308 1047.58 46.9338 L1047.58 72.576 L1040.09 72.576 L1040.09 27.2059 L1047.58 27.2059 L1047.58 34.2544 Q1050.13 30.082 1053.7 28.0971 Q1057.26 26.1121 1062.16 26.1121 Q1067.11 26.1121 1070.55 28.6237 Q1074.03 31.1352 1075.69 35.9153 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1128.4 65.7705 L1128.4 89.8329 L1120.9 89.8329 L1120.9 27.2059 L1128.4 27.2059 L1128.4 34.0924 Q1130.74 30.0415 1134.31 28.0971 Q1137.91 26.1121 1142.9 26.1121 Q1151.16 26.1121 1156.31 32.6746 Q1161.49 39.2371 1161.49 49.9314 Q1161.49 60.6258 1156.31 67.1883 Q1151.16 73.7508 1142.9 73.7508 Q1137.91 73.7508 1134.31 71.8063 Q1130.74 69.8214 1128.4 65.7705 M1153.75 49.9314 Q1153.75 41.7081 1150.35 37.0496 Q1146.99 32.3505 1141.07 32.3505 Q1135.16 32.3505 1131.76 37.0496 Q1128.4 41.7081 1128.4 49.9314 Q1128.4 58.1548 1131.76 62.8538 Q1135.16 67.5124 1141.07 67.5124 Q1146.99 67.5124 1150.35 62.8538 Q1153.75 58.1548 1153.75 49.9314 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1173.85 9.54393 L1181.3 9.54393 L1181.3 72.576 L1173.85 72.576 L1173.85 9.54393 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1196.9 27.2059 L1204.35 27.2059 L1204.35 72.576 L1196.9 72.576 L1196.9 27.2059 M1196.9 9.54393 L1204.35 9.54393 L1204.35 18.9825 L1196.9 18.9825 L1196.9 9.54393 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1252.6 28.9478 L1252.6 35.9153 Q1249.44 34.1734 1246.24 33.3227 Q1243.08 32.4315 1239.84 32.4315 Q1232.58 32.4315 1228.57 37.0496 Q1224.56 41.6271 1224.56 49.9314 Q1224.56 58.2358 1228.57 62.8538 Q1232.58 67.4314 1239.84 67.4314 Q1243.08 67.4314 1246.24 66.5807 Q1249.44 65.6895 1252.6 63.9476 L1252.6 70.8341 Q1249.48 72.2924 1246.11 73.0216 Q1242.79 73.7508 1239.03 73.7508 Q1228.78 73.7508 1222.74 67.3098 Q1216.7 60.8689 1216.7 49.9314 Q1216.7 38.832 1222.78 32.472 Q1228.9 26.1121 1239.51 26.1121 Q1242.95 26.1121 1246.24 26.8413 Q1249.52 27.5299 1252.6 28.9478 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1286.18 49.7694 Q1277.14 49.7694 1273.66 51.8354 Q1270.18 53.9013 1270.18 58.8839 Q1270.18 62.8538 1272.77 65.2034 Q1275.4 67.5124 1279.9 67.5124 Q1286.1 67.5124 1289.82 63.1374 Q1293.59 58.7219 1293.59 51.4303 L1293.59 49.7694 L1286.18 49.7694 M1301.04 46.6907 L1301.04 72.576 L1293.59 72.576 L1293.59 65.6895 Q1291.04 69.8214 1287.23 71.8063 Q1283.42 73.7508 1277.91 73.7508 Q1270.95 73.7508 1266.81 69.8619 Q1262.72 65.9325 1262.72 59.3701 Q1262.72 51.7138 1267.83 47.825 Q1272.97 43.9361 1283.14 43.9361 L1293.59 43.9361 L1293.59 43.2069 Q1293.59 38.0623 1290.19 35.2672 Q1286.83 32.4315 1280.71 32.4315 Q1276.82 32.4315 1273.13 33.3632 Q1269.45 34.295 1266.04 36.1584 L1266.04 29.2718 Q1270.14 27.692 1273.98 26.9223 Q1277.83 26.1121 1281.48 26.1121 Q1291.32 26.1121 1296.18 31.2163 Q1301.04 36.3204 1301.04 46.6907 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1323.77 14.324 L1323.77 27.2059 L1339.12 27.2059 L1339.12 32.9987 L1323.77 32.9987 L1323.77 57.6282 Q1323.77 63.1779 1325.27 64.7578 Q1326.81 66.3376 1331.47 66.3376 L1339.12 66.3376 L1339.12 72.576 L1331.47 72.576 Q1322.84 72.576 1319.56 69.3758 Q1316.28 66.1351 1316.28 57.6282 L1316.28 32.9987 L1310.81 32.9987 L1310.81 27.2059 L1316.28 27.2059 L1316.28 14.324 L1323.77 14.324 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1387.73 48.0275 L1387.73 51.6733 L1353.46 51.6733 Q1353.95 59.3701 1358.08 63.421 Q1362.25 67.4314 1369.67 67.4314 Q1373.96 67.4314 1377.97 66.3781 Q1382.02 65.3249 1385.99 63.2184 L1385.99 70.267 Q1381.98 71.9684 1377.77 72.8596 Q1373.56 73.7508 1369.22 73.7508 Q1358.37 73.7508 1352.01 67.4314 Q1345.69 61.1119 1345.69 50.3365 Q1345.69 39.1965 1351.68 32.6746 Q1357.72 26.1121 1367.93 26.1121 Q1377.08 26.1121 1382.39 32.0264 Q1387.73 37.9003 1387.73 48.0275 M1380.28 45.84 Q1380.2 39.7232 1376.84 36.0774 Q1373.52 32.4315 1368.01 32.4315 Q1361.77 32.4315 1358 35.9558 Q1354.27 39.4801 1353.71 45.8805 L1380.28 45.84 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1429.82 34.0924 L1429.82 9.54393 L1437.28 9.54393 L1437.28 72.576 L1429.82 72.576 L1429.82 65.7705 Q1427.47 69.8214 1423.87 71.8063 Q1420.3 73.7508 1415.28 73.7508 Q1407.06 73.7508 1401.87 67.1883 Q1396.73 60.6258 1396.73 49.9314 Q1396.73 39.2371 1401.87 32.6746 Q1407.06 26.1121 1415.28 26.1121 Q1420.3 26.1121 1423.87 28.0971 Q1427.47 30.0415 1429.82 34.0924 M1404.42 49.9314 Q1404.42 58.1548 1407.79 62.8538 Q1411.19 67.5124 1417.1 67.5124 Q1423.02 67.5124 1426.42 62.8538 Q1429.82 58.1548 1429.82 49.9314 Q1429.82 41.7081 1426.42 37.0496 Q1423.02 32.3505 1417.1 32.3505 Q1411.19 32.3505 1407.79 37.0496 Q1404.42 41.7081 1404.42 49.9314 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1486.21 65.7705 L1486.21 89.8329 L1478.72 89.8329 L1478.72 27.2059 L1486.21 27.2059 L1486.21 34.0924 Q1488.56 30.0415 1492.13 28.0971 Q1495.73 26.1121 1500.71 26.1121 Q1508.98 26.1121 1514.12 32.6746 Q1519.31 39.2371 1519.31 49.9314 Q1519.31 60.6258 1514.12 67.1883 Q1508.98 73.7508 1500.71 73.7508 Q1495.73 73.7508 1492.13 71.8063 Q1488.56 69.8214 1486.21 65.7705 M1511.57 49.9314 Q1511.57 41.7081 1508.17 37.0496 Q1504.81 32.3505 1498.89 32.3505 Q1492.98 32.3505 1489.57 37.0496 Q1486.21 41.7081 1486.21 49.9314 Q1486.21 58.1548 1489.57 62.8538 Q1492.98 67.5124 1498.89 67.5124 Q1504.81 67.5124 1508.17 62.8538 Q1511.57 58.1548 1511.57 49.9314 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1531.66 9.54393 L1539.12 9.54393 L1539.12 72.576 L1531.66 72.576 L1531.66 9.54393 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1572.29 32.4315 Q1566.3 32.4315 1562.81 37.1306 Q1559.33 41.7891 1559.33 49.9314 Q1559.33 58.0738 1562.77 62.7728 Q1566.26 67.4314 1572.29 67.4314 Q1578.25 67.4314 1581.73 62.7323 Q1585.22 58.0333 1585.22 49.9314 Q1585.22 41.8701 1581.73 37.1711 Q1578.25 32.4315 1572.29 32.4315 M1572.29 26.1121 Q1582.02 26.1121 1587.57 32.4315 Q1593.11 38.7509 1593.11 49.9314 Q1593.11 61.0714 1587.57 67.4314 Q1582.02 73.7508 1572.29 73.7508 Q1562.53 73.7508 1556.98 67.4314 Q1551.47 61.0714 1551.47 49.9314 Q1551.47 38.7509 1556.98 32.4315 Q1562.53 26.1121 1572.29 26.1121 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M1612.84 14.324 L1612.84 27.2059 L1628.2 27.2059 L1628.2 32.9987 L1612.84 32.9987 L1612.84 57.6282 Q1612.84 63.1779 1614.34 64.7578 Q1615.88 66.3376 1620.54 66.3376 L1628.2 66.3376 L1628.2 72.576 L1620.54 72.576 Q1611.91 72.576 1608.63 69.3758 Q1605.35 66.1351 1605.35 57.6282 L1605.35 32.9987 L1599.88 32.9987 L1599.88 27.2059 L1605.35 27.2059 L1605.35 14.324 L1612.84 14.324 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip602)\" style=\"stroke:#ff0000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:8; stroke-opacity:1; fill:none\" points=\"\n",
       "  264.778,509.86 278.475,534.839 292.173,559.447 305.87,583.682 319.567,607.546 333.264,631.038 346.961,654.157 360.658,676.905 374.355,699.281 388.052,721.284 \n",
       "  401.749,742.916 415.446,764.176 429.143,785.063 442.84,805.579 456.537,825.723 470.234,845.494 483.931,864.894 497.628,883.922 511.325,902.577 525.022,920.861 \n",
       "  538.719,938.773 552.416,956.312 566.113,973.48 579.81,990.276 593.508,1006.7 607.205,1022.75 620.902,1038.43 634.599,1053.74 648.296,1068.67 661.993,1083.24 \n",
       "  675.69,1097.43 689.387,1111.25 703.084,1124.7 716.781,1137.77 730.478,1150.48 744.175,1162.81 757.872,1174.77 771.569,1186.36 785.266,1197.57 798.963,1208.42 \n",
       "  812.66,1218.89 826.357,1228.99 840.054,1238.71 853.751,1248.07 867.448,1257.05 881.145,1265.67 894.842,1273.91 908.54,1281.77 922.237,1289.27 935.934,1296.39 \n",
       "  949.631,1303.14 963.328,1309.52 977.025,1315.53 990.722,1321.17 1004.42,1326.43 1018.12,1331.32 1031.81,1335.84 1045.51,1339.99 1059.21,1343.77 1072.9,1347.17 \n",
       "  1086.6,1350.2 1100.3,1352.86 1114,1355.15 1127.69,1357.07 1141.39,1358.61 1155.09,1359.78 1168.78,1360.58 1182.48,1361.01 1196.18,1361.06 1209.87,1360.75 \n",
       "  1223.57,1360.06 1237.27,1359 1250.97,1357.57 1264.66,1355.76 1278.36,1353.59 1292.06,1351.04 1305.75,1348.12 1319.45,1344.83 1333.15,1341.16 1346.84,1337.13 \n",
       "  1360.54,1332.72 1374.24,1327.94 1387.94,1322.79 1401.63,1317.26 1415.33,1311.37 1429.03,1305.1 1442.72,1298.46 1456.42,1291.44 1470.12,1284.06 1483.82,1276.3 \n",
       "  1497.51,1268.18 1511.21,1259.68 1524.91,1250.8 1538.6,1241.56 1552.3,1231.94 1566,1221.96 1579.69,1211.6 1593.39,1200.86 1607.09,1189.76 1620.79,1178.28 \n",
       "  1634.48,1166.44 1648.18,1154.22 1661.88,1141.62 1675.57,1128.66 1689.27,1115.32 1702.97,1101.61 1716.67,1087.53 1730.36,1073.08 1744.06,1058.26 1757.76,1043.06 \n",
       "  1771.45,1027.49 1785.15,1011.55 1798.85,995.242 1812.54,978.558 1826.24,961.502 1839.94,944.074 1853.64,926.274 1867.33,908.102 1881.03,889.557 1894.73,870.641 \n",
       "  1908.42,851.353 1922.12,831.693 1935.82,811.661 1949.51,791.257 1963.21,770.481 1976.91,749.333 1990.61,727.813 2004.3,705.921 2018,683.657 2031.7,661.021 \n",
       "  2045.39,638.013 2059.09,614.633 2072.79,590.881 2086.49,566.757 2100.18,542.261 2113.88,517.393 2127.58,492.152 2141.27,466.54 2154.97,440.556 2168.67,414.2 \n",
       "  2182.36,387.472 2196.06,360.372 2209.76,332.9 2223.46,305.056 2237.15,276.84 2250.85,248.252 2264.55,219.292 2278.24,189.96 2291.94,160.256 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip602)\" style=\"stroke:#0000ff; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" stroke-dasharray=\"16, 10\" points=\"\n",
       "  264.778,1385.9 278.475,1385.37 292.173,1384.67 305.87,1383.78 319.567,1382.72 333.264,1381.48 346.961,1380.08 360.658,1378.51 374.355,1376.79 388.052,1374.92 \n",
       "  401.749,1372.9 415.446,1370.75 429.143,1368.46 442.84,1366.06 456.537,1363.55 470.234,1360.93 483.931,1358.23 497.628,1355.44 511.325,1352.57 525.022,1349.65 \n",
       "  538.719,1346.67 552.416,1343.66 566.113,1340.62 579.81,1337.55 593.508,1334.48 607.205,1331.42 620.902,1328.37 634.599,1325.35 648.296,1322.37 661.993,1319.44 \n",
       "  675.69,1316.56 689.387,1313.76 703.084,1311.04 716.781,1308.41 730.478,1305.88 744.175,1303.46 757.872,1301.15 771.569,1298.98 785.266,1296.94 798.963,1295.04 \n",
       "  812.66,1293.29 826.357,1291.7 840.054,1290.27 853.751,1289.01 867.448,1287.92 881.145,1287 894.842,1286.26 908.54,1285.71 922.237,1285.34 935.934,1285.15 \n",
       "  949.631,1285.15 963.328,1285.34 977.025,1285.71 990.722,1286.26 1004.42,1287 1018.12,1287.92 1031.81,1289.01 1045.51,1290.27 1059.21,1291.7 1072.9,1293.29 \n",
       "  1086.6,1295.04 1100.3,1296.94 1114,1298.98 1127.69,1301.15 1141.39,1303.46 1155.09,1305.88 1168.78,1308.41 1182.48,1311.04 1196.18,1313.76 1209.87,1316.56 \n",
       "  1223.57,1319.44 1237.27,1322.37 1250.97,1325.35 1264.66,1328.37 1278.36,1331.42 1292.06,1334.48 1305.75,1337.55 1319.45,1340.62 1333.15,1343.66 1346.84,1346.67 \n",
       "  1360.54,1349.65 1374.24,1352.57 1387.94,1355.44 1401.63,1358.23 1415.33,1360.93 1429.03,1363.55 1442.72,1366.06 1456.42,1368.46 1470.12,1370.75 1483.82,1372.9 \n",
       "  1497.51,1374.92 1511.21,1376.79 1524.91,1378.51 1538.6,1380.08 1552.3,1381.48 1566,1382.72 1579.69,1383.78 1593.39,1384.67 1607.09,1385.37 1620.79,1385.9 \n",
       "  1634.48,1386.24 1648.18,1386.4 1661.88,1386.37 1675.57,1386.15 1689.27,1385.75 1702.97,1385.16 1716.67,1384.4 1730.36,1383.45 1744.06,1382.33 1757.76,1381.04 \n",
       "  1771.45,1379.58 1785.15,1377.97 1798.85,1376.19 1812.54,1374.27 1826.24,1372.21 1839.94,1370.01 1853.64,1367.69 1867.33,1365.25 1881.03,1362.7 1894.73,1360.06 \n",
       "  1908.42,1357.32 1922.12,1354.51 1935.82,1351.62 1949.51,1348.68 1963.21,1345.69 1976.91,1342.67 1990.61,1339.61 2004.3,1336.55 2018,1333.48 2031.7,1330.42 \n",
       "  2045.39,1327.38 2059.09,1324.37 2072.79,1321.4 2086.49,1318.49 2100.18,1315.64 2113.88,1312.86 2127.58,1310.17 2141.27,1307.57 2154.97,1305.07 2168.67,1302.69 \n",
       "  2182.36,1300.43 2196.06,1298.3 2209.76,1296.3 2223.46,1294.45 2237.15,1292.75 2250.85,1291.22 2264.55,1289.84 2278.24,1288.63 2291.94,1287.6 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip600)\" d=\"\n",
       "M1932.4 322.316 L2281.13 322.316 L2281.13 166.796 L1932.4 166.796  Z\n",
       "  \" fill=\"#ffffff\" fill-rule=\"evenodd\" fill-opacity=\"1\"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#000000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1932.4,322.316 2281.13,322.316 2281.13,166.796 1932.4,166.796 1932.4,322.316 \n",
       "  \"/>\n",
       "<polyline clip-path=\"url(#clip600)\" style=\"stroke:#ff0000; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" points=\"\n",
       "  1956.4,218.636 2100.4,218.636 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip600)\" d=\"M2140.91 199.897 L2140.91 203.439 L2136.83 203.439 Q2134.54 203.439 2133.64 204.365 Q2132.76 205.291 2132.76 207.698 L2132.76 209.99 L2139.77 209.99 L2139.77 213.3 L2132.76 213.3 L2132.76 235.916 L2128.48 235.916 L2128.48 213.3 L2124.4 213.3 L2124.4 209.99 L2128.48 209.99 L2128.48 208.184 Q2128.48 203.856 2130.49 201.888 Q2132.51 199.897 2136.88 199.897 L2140.91 199.897 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M2166.02 220.268 L2166.02 235.916 L2161.76 235.916 L2161.76 220.407 Q2161.76 216.726 2160.33 214.897 Q2158.89 213.069 2156.02 213.069 Q2152.57 213.069 2150.58 215.268 Q2148.59 217.467 2148.59 221.263 L2148.59 235.916 L2144.31 235.916 L2144.31 209.99 L2148.59 209.99 L2148.59 214.018 Q2150.12 211.68 2152.18 210.522 Q2154.26 209.365 2156.97 209.365 Q2161.44 209.365 2163.73 212.143 Q2166.02 214.897 2166.02 220.268 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M2175.93 231.981 L2183.57 231.981 L2183.57 205.615 L2175.26 207.282 L2175.26 203.022 L2183.52 201.356 L2188.2 201.356 L2188.2 231.981 L2195.84 231.981 L2195.84 235.916 L2175.93 235.916 L2175.93 231.981 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M2214.91 199.944 Q2211.81 205.268 2210.31 210.476 Q2208.8 215.684 2208.8 221.032 Q2208.8 226.379 2210.31 231.633 Q2211.83 236.865 2214.91 242.166 L2211.21 242.166 Q2207.74 236.726 2206 231.471 Q2204.29 226.217 2204.29 221.032 Q2204.29 215.87 2206 210.638 Q2207.71 205.407 2211.21 199.944 L2214.91 199.944 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M2222.5 199.944 L2226.21 199.944 Q2229.68 205.407 2231.39 210.638 Q2233.13 215.87 2233.13 221.032 Q2233.13 226.217 2231.39 231.471 Q2229.68 236.726 2226.21 242.166 L2222.5 242.166 Q2225.58 236.865 2227.09 231.633 Q2228.62 226.379 2228.62 221.032 Q2228.62 215.684 2227.09 210.476 Q2225.58 205.268 2222.5 199.944 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><polyline clip-path=\"url(#clip600)\" style=\"stroke:#0000ff; stroke-linecap:butt; stroke-linejoin:round; stroke-width:4; stroke-opacity:1; fill:none\" stroke-dasharray=\"16, 10\" points=\"\n",
       "  1956.4,270.476 2100.4,270.476 \n",
       "  \"/>\n",
       "<path clip-path=\"url(#clip600)\" d=\"M2144.91 262.825 L2144.91 266.807 Q2143.11 265.811 2141.28 265.325 Q2139.47 264.816 2137.62 264.816 Q2133.48 264.816 2131.19 267.455 Q2128.89 270.071 2128.89 274.816 Q2128.89 279.561 2131.19 282.2 Q2133.48 284.816 2137.62 284.816 Q2139.47 284.816 2141.28 284.33 Q2143.11 283.821 2144.91 282.825 L2144.91 286.76 Q2143.13 287.594 2141.21 288.01 Q2139.31 288.427 2137.16 288.427 Q2131.3 288.427 2127.85 284.746 Q2124.4 281.066 2124.4 274.816 Q2124.4 268.473 2127.88 264.839 Q2131.37 261.205 2137.44 261.205 Q2139.4 261.205 2141.28 261.622 Q2143.15 262.015 2144.91 262.825 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M2162.37 264.816 Q2158.94 264.816 2156.95 267.501 Q2154.96 270.163 2154.96 274.816 Q2154.96 279.469 2156.93 282.154 Q2158.92 284.816 2162.37 284.816 Q2165.77 284.816 2167.76 282.131 Q2169.75 279.446 2169.75 274.816 Q2169.75 270.21 2167.76 267.524 Q2165.77 264.816 2162.37 264.816 M2162.37 261.205 Q2167.92 261.205 2171.09 264.816 Q2174.26 268.427 2174.26 274.816 Q2174.26 281.182 2171.09 284.816 Q2167.92 288.427 2162.37 288.427 Q2156.79 288.427 2153.62 284.816 Q2150.47 281.182 2150.47 274.816 Q2150.47 268.427 2153.62 264.816 Q2156.79 261.205 2162.37 261.205 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /><path clip-path=\"url(#clip600)\" d=\"M2197.85 262.594 L2197.85 266.622 Q2196.05 265.696 2194.1 265.233 Q2192.16 264.77 2190.07 264.77 Q2186.9 264.77 2185.31 265.742 Q2183.73 266.714 2183.73 268.659 Q2183.73 270.14 2184.87 270.997 Q2186 271.83 2189.43 272.594 L2190.88 272.918 Q2195.42 273.89 2197.32 275.672 Q2199.24 277.432 2199.24 280.603 Q2199.24 284.214 2196.37 286.321 Q2193.52 288.427 2188.52 288.427 Q2186.44 288.427 2184.17 288.01 Q2181.93 287.617 2179.43 286.807 L2179.43 282.409 Q2181.79 283.635 2184.08 284.26 Q2186.37 284.862 2188.62 284.862 Q2191.63 284.862 2193.25 283.844 Q2194.87 282.802 2194.87 280.927 Q2194.87 279.191 2193.69 278.265 Q2192.53 277.339 2188.57 276.483 L2187.09 276.135 Q2183.13 275.302 2181.37 273.589 Q2179.61 271.853 2179.61 268.844 Q2179.61 265.186 2182.2 263.196 Q2184.8 261.205 2189.56 261.205 Q2191.93 261.205 2194.01 261.552 Q2196.09 261.899 2197.85 262.594 Z\" fill=\"#000000\" fill-rule=\"evenodd\" fill-opacity=\"1\" /></svg>\n"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot( [x x],[fn1.(x) cos.(x)],\n",
    "           linecolor = [:red :blue],\n",
    "           linestyle = [:solid :dash],\n",
    "           linewidth = [2 1],\n",
    "           label = [\"fn1()\" \"cos\"],\n",
    "           title = \"Complicated plot\",\n",
    "           xlabel = \"Input value\",\n",
    "           ylabel = \"Output value\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use plotting in all of the future tutorials, so this is worthwhile investing some time trying to learn the basics. For those of you who are interested in visualisation in programming, for Python you will most likely work with `matplotlib` and in R the `ggplot` package is quite popular."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Type system (`advanced` + `optional`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This final section is optional, but I would recommend simply reading through it. There are some really valuable things about the way that Julia works as a language. However, if you have no interest in this type of thing you can safely skip the section. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia is different from languages like Python and R, in that it does not really work with objects. In Julia the important abstraction is the type. \n",
    "\n",
    "Everything in Julia has some type, which in turn may be a subtype of something else. In this section we will explore the basics of the type system. Once again, this is a bit more complicated / technical, but worth exploring if you really like the Julia language. \n",
    "\n",
    "Below is a diagram of a type hierarchy of the `Number` type in Julia. \n",
    "\n",
    "![](../images/types.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All types depicted in blue are abstract types and the green are concrete types. \n",
    "\n",
    "Let us consider a type that we have dealt with, for example the `Int64` type. \n",
    "\n",
    "`Int64` is a concrete type in Julia, as opposed to an abstract type. \n",
    "\n",
    "Concretes types are the last in the type hierarchy. In other words, there are no subtypes below `Int64` in Julia. \n",
    "\n",
    "However, there are types that lie \"above\" `Int64` in the type hierarchy. \n",
    "\n",
    "If you consider the subgraph of `Int64` you will see the following. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Int64 <: Signed <: Integer <: Real <: Number <: Any"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What this line of code says is that `Int64` is a subtype of all the components to the right of it. The `<:` operator basically says that the left component is a subtype of the right. \n",
    "\n",
    "In other words, `Int64` is a subtype of the `Integer` type. \n",
    "\n",
    "The `Integer` type in this case is a abstract type (which we cover in the section below), since there are subtypes below it (such as `Signed` and `Int64`).\n",
    "\n",
    "You can take a look at the type tree below, which should give some indication on the hierarchy between types. You will see that concrete types are last in the hierarchy (the terminal nodes). Examples include `Int128`, `Int64` and so forth. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integer\n",
      " ├─ Bool\n",
      " ├─ GeometryBasics.OffsetInteger\n",
      " ├─ Signed\n",
      " │   ├─ BigInt\n",
      " │   ├─ Int128\n",
      " │   ├─ Int16\n",
      " │   ├─ Int32\n",
      " │   ├─ Int64\n",
      " │   └─ Int8\n",
      " └─ Unsigned\n",
      "     ├─ UInt128\n",
      "     ├─ UInt16\n",
      "     ├─ UInt32\n",
      "     ├─ UInt64\n",
      "     └─ UInt8\n"
     ]
    }
   ],
   "source": [
    "print(join(tt(Integer), \"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type annotations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have seen type annotations in our section on functions. In other words, we have something along the lines of `x::Int64`. This indicates that `x` is of the type `Int64`. \n",
    "\n",
    "This is basically how you tell Julia's compiler that `x` is of the type `Int64`. \n",
    "\n",
    "However, what if we are not sure that `x` is going to be an `Int64`, but we know that it will be a number. Then we it is possible to say `x::Number`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we state that something is of a certain type but this is not true, then we will receive a `TypeError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "TypeError: in typeassert, expected Float64, got a value of type Int64",
     "output_type": "error",
     "traceback": [
      "TypeError: in typeassert, expected Float64, got a value of type Int64",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[177]:1",
      " [2] eval",
      "   @ .\\boot.jl:373 [inlined]",
      " [3] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base .\\loading.jl:1196"
     ]
    }
   ],
   "source": [
    "10::Float64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this error message it tells you: \"expected Float64, got a value of type Int64\". This means you put down an integer and the compiler was expecting a floating point number. However, if you were uncertain of the type of the input you could have had a more general type, such as `Number` instead. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10::Number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What can we take from this, in defining functions we can often use type annotations to give an idea fo the type that we expect. There is a good reason for doing this with functions, which is related to the concept of **multiple dispatch** (a key feature that makes Julia a really special language)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Abstract types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the core of the type system is the abstract type. \n",
    "\n",
    "Abstract types cannot be **instantiated**. This means that we cannot create them explicitly. \n",
    "\n",
    "They are just a way to **organise** the types that we have. \n",
    "\n",
    "If you want to construct an abstract type you would do it as follows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "cannot assign a value to variable Core.Number from module Main",
     "output_type": "error",
     "traceback": [
      "cannot assign a value to variable Core.Number from module Main",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[179]:1",
      " [2] eval",
      "   @ .\\boot.jl:373 [inlined]",
      " [3] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base .\\loading.jl:1196"
     ]
    }
   ],
   "source": [
    "abstract type Number end # Number is a subtype of Any\n",
    "abstract type Real <: Number end # Real is a subtype of Number\n",
    "abstract type AbstractFloat <: Real end # AbstractFloat is a subtype of Real and by extension Number\n",
    "abstract type AbstractIrrational <: Real end # AbstractIrrational is a subtype of Real and by extension Number\n",
    "abstract type Integer <: Real end # Integer is a subtype of Real\n",
    "abstract type Signed <: Integer end # Signed is a subtype of Integer\n",
    "abstract type Unsigned <: Integer end # Unsigned is a subtype of Integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Composite types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The things that we can instantiate are called **structs**. \n",
    "\n",
    "A `struct` is a wrapper around some field. These `structs` are referred to as *composite types*.  \n",
    "\n",
    "A composite type is a collection of key-value pairs.\n",
    "\n",
    "This is not easy to understand at first, so let us use some example to make this clear. \n",
    "\n",
    "In the following example we will be con**struct**ing a `struct`. This `struct` has no supertype defined here. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct FirstStruct\n",
    "    field::Float64\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This struct contains one field, which is of the type `Float64`. The input for this struct need to be of type `Float64`, otherwise the call will not work. \n",
    "\n",
    "If the type annotation is omitted, `Any` is used, and such a field may contain any value.\n",
    "\n",
    "We can create a new instance of the above type by calling `FirstStruct` as a function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FirstStruct(1.2)"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = FirstStruct(1.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the field value for this composite type via dot notation, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.field"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Happiness example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will combine **structs** and **abstract types**. \n",
    "\n",
    "Remember that abstract types are there to organise the structs. \n",
    "\n",
    "We start with the highest level type first. \n",
    "\n",
    "In our example we are going to be creating a `Happiness` type, which reflects the overall happiness in the economy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "abstract type Happiness end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we think about specific **subtypes** that might be related in some way to happiness within the economy. \n",
    "\n",
    "In this case I thought about GDP, which contains components such as investment and consumption. These factors might contribute to happiness. GDP is a measure of income, not wealth. So perhaps not the best way to determine happiness, but let us use it.  \n",
    "\n",
    "In addition, health considerations might also be important for happiness within the economy.\n",
    "\n",
    "You can imagine your own particular type system here. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "abstract type GDP <: Happiness end\n",
    "abstract type Health <: Happiness end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our example, we can decompose GDP into its to main components. First, we have consumption expenditure on either goods and services. We can think about an increase in consumption indicating higher GDP and therefore greater happiness. This is very superficial, but play along for now. \n",
    "\n",
    "We can also look at different types of investment. Most important for happiness might be residential investment. However, an increase in investment normally leads to higher job creation and in return higher levels of happiness. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Consumption <: GDP\n",
    "    goods::Float64\n",
    "    services::Float64\n",
    "end\n",
    "\n",
    "struct Investment <: GDP\n",
    "    inventory::Float64\n",
    "    residential::Float64\n",
    "    non_residential::Float64\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In terms of the health component, let us say that Covid is currently the only disease that people care about. If you have Covid this tends to make you unhappy, and if you don't you are lucky and generally happy about it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "abstract type Sick <: Health end\n",
    "\n",
    "struct Covid <: Sick\n",
    "    positive::Bool\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to instantiate some of these structs that we have made, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Investment(130.86, 201.54, 335.12)"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "consumption_2021 = Consumption(1205.45, 980.57)\n",
    "investment_2021 = Investment(130.86, 201.54, 335.12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Covid(true)"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "covid_pos_2021 = Covid(true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can create a function that determines if we are happy based on the type of the input. This is where the idea of multiple dispatch comes in. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "happy (generic function with 1 method)"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "happy(x::Investment) = true"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far this function, called `happy()`, gives us the result `true` if the input type is `Investment`. Let us extend the function even more. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "happy (generic function with 2 methods)"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "happy(x::Consumption) = if consumption_2021.goods + consumption_2021.services > 1000 return true end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now see that the function `happy()` is a function with two methods. That means that for different inputs it will perform different actions. In this case if the type is `Investment` the returned value will be true. If the input is `Consumption` then combined the values of the goods and services fields need to be greater than 1000 for the value to be `true`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "happy (generic function with 3 methods)"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "happy(x::Covid) = false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This last bit of code now tells us that whenever the input type is reflects us being Covid positive, then we are not happy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Bool}:\n",
       " 1\n",
       " 1\n",
       " 0"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(happy, [consumption_2021, investment_2021, covid_pos_2021])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see from the output above that instances of Consumption and Investment return `true` values. Boolean output of `1` is the same as `true`. In the case of being Covid positive we are not happy. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.7.2",
   "language": "julia",
   "name": "julia-1.7"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.7.2"
  },
  "nteract": {
   "version": "0.25.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}