Tutorials/julia_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Julia\n",
    "\n",
    "Reference: This tutorial is based on a tutorial presented at the [JuMP-dev 2019](https://github.com/juan-pablo-vielma/JuMP-dev-2019-tutorial), and examples are adapted from the [Kamiński, Bogumił. 2023. Julia for Data Analysis. Manning.](https://github.com/bkamins/JuliaForDataAnalysis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other Resources\n",
    "\n",
    "This notebook is designed to provide a minimalist crash course in the basics of Julia. Other resources:\n",
    "* [Intro to Julia](https://youtu.be/r2d5NA7RHno)  \n",
    "\n",
    "* [“Learn X in Y Minutes”](https://learnxinyminutes.com/docs/julia/) \n",
    "* [From Zero to Julia!](https://techytok.com/from-zero-to-julia/) \n",
    "\n",
    "* [Julia Cheatsheet](https://cheatsheet.juliadocs.org/)\n",
    "* [Cheatsheet of basic functions](https://cheatsheets.quantecon.org/julia-cheatsheet.html)\n",
    "* [Plots Cheatsheet](https://github.com/sswatson/cheatsheets/blob/master/plotsjl-cheatsheet.pdf)\n",
    "\n",
    "* [Cheatsheet for differences between Julia and Matlab and Python](https://cheatsheets.quantecon.org/)\n",
    "\n",
    "* [Think Julia: How to Think Like a Computer Scientist](https://benlauwens.github.io/ThinkJulia.jl/latest/book.html#chap01)\n",
    "\n",
    "* [Advanced Scientific Computing - Tim Holy](https://github.com/timholy/AdvancedScientificComputing/tree/main)\n",
    "\n",
    "* [Official documentation](https://docs.julialang.org/en/v1/)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "- Julia is a general purpose, multi-platform, (strongly) dynamically typed, high-performance, programming language well suited for **numerical analysis** and **computational science**.  \n",
    "\n",
    "- Julia programs compile to efficient native code for multiple platforms via LLVM that allows it to match the performance of languages such as C and FORTRAN without the hassle of low-level code. \n",
    "\n",
    "- Because the code is compiled on the fly you can run code in a shell or REPL, which is part of the recommended workflow .\n",
    "\n",
    "- Julia has a built-in package manager.\n",
    "\n",
    "- Julia was created in 2012."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the REPL\n",
    "- Recall last result \t`ans`\n",
    "\n",
    "- Interrupt execution \t`[Ctrl] + [C]`  \n",
    "\n",
    "- Clear screen \t`[Ctrl] + [L]  `\n",
    "\n",
    "- Run program \t`include(\"filename.jl\")`  \n",
    "\n",
    "- Package Manager mode \t`]` on empty line  \n",
    "\n",
    "- Help mode \t`?` on empty line  \n",
    "\n",
    "- Exit REPL \t`exit()` or `[Ctrl] + [D]` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Packages and the Package Manager"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Package Manager is used to install packages that are not part of Julia's standard library.\n",
    "\n",
    "For example the following can be used to install JuMP,\n",
    "```julia\n",
    "using Pkg\n",
    "Pkg.add(\"JuMP\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Vector{Float64}:\n",
       " 0.5777380114136625\n",
       " 0.6470426889546197\n",
       " 0.05546299043159453\n",
       " 0.004681112985528313\n",
       " 0.0928497340411405\n",
       " 0.21978318106147177\n",
       " 0.7619240566076749\n",
       " 0.17230398520738754\n",
       " 0.43125831795824987\n",
       " 0.014667241816034626"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "using Random\n",
    "[rand() for i in 1:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "For a complete list of registed Julia packages see the package listing at https://pkg.julialang.org/.\n",
    "\n",
    "From time to you may wish to use a Julia package that is not registered.  In this case a git repository URL can be used to install the package.\n",
    "```julia\n",
    "using Pkg\n",
    "Pkg.add(\"https://github.com/user-name/MyPackage.jl.git\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### USEFUL COMMANDS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- List installed packages (human-readable) \t`Pkg.status()`\n",
    "\n",
    "- Update all packages \t`Pkg.update()`  \n",
    "\n",
    "- Install PackageName \t`Pkg.add(\"PackageName\")`  \n",
    "\n",
    "- Rebuild PackageName \t`Pkg.build(\"PackageName\") ` \n",
    "\n",
    "- Use PackageName (after install) \t`using PackageName`\n",
    "\n",
    "- Remove PackageName \t`Pkg.rm(\"PackageName\")`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "In Interactive Package Mode\n",
    "\n",
    "- Add PackageName \t`add PackageName`\n",
    "\n",
    "- Remove PackageName \t`rm PackageName`\n",
    "\n",
    "- Update PackageName \t`update PackageName`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### HELP!\n",
    "\n",
    "Julia 1.0 includes a help mode that can be accessed using `?`.  Entering any object (e.g. function, type, struct, ...) into the help mode will show its documentation, if any is available.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Data Types\n",
    "\n",
    "Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "1 + -2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Floating point numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0999999999999999"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "1.2 - 2.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(-1.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also some cool things like an irrational representation of π. To make π (and most other greek letters), type \\pi and then press [TAB]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "π = 3.1415926535897..."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "π"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "julia allows Unicode names (in UTF-8 encoding) so either \"pi\" or the symbol π can be used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Irrational{:π}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(π)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia has native support for complex numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2 + 3im"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "2 + 3im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Complex{Int64}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(2 + 3im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.974182454814718"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "exp(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double quotes are used for strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"This is Julia\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"This is Julia\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "String"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(\"This is Julia\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unicode is fine in strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"π is about 3.1415\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"π is about 3.1415\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single quote for characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Char"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "'b'\n",
    "typeof('b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String literals are encoded using the UTF-8 encoding:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "σ = 2\n",
    "𝒮 = 4   # \\scrS  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "😀 = 10\n",
    "🥲 = -10\n",
    "😀 + 🥲"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm Julia. Nice to meet you!\n"
     ]
    }
   ],
   "source": [
    "println(\"I'm Julia. Nice to meet you!\")  # => I'm Julia. Nice to meet you!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 + 10 = 12\n",
      "2 ^ 3 = 8\n",
      "3 / 12 = 0.25\n",
      "3 // 12 = 1//4\n",
      "(1 + 3) * 2 = 8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@show 2 + 10  # 12\n",
    "@show 2^3     # 8\n",
    "@show 3/12    # 0.25\n",
    "@show 3//12\n",
    "# Enforce precedence with parentheses\n",
    "@show (1 + 3) * 2  # => 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even math involving complex numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4 - 3im"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(2 + 1im) * (1 - 2im)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical operations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = (b = 6) = 6\n",
      "!true = false\n",
      "a == b = true\n",
      "a != b = false\n",
      "a > b = false\n",
      "a >= b = true\n",
      "a < b = false\n",
      "a <= b = true\n"
     ]
    }
   ],
   "source": [
    "@show a = b = 6   # assignment\n",
    "@show !true       # false: negation\n",
    "@show a == b      # equality\n",
    "@show a != b      # inequality\n",
    "@show a > b       # larger\n",
    "@show a >= b      # greater than or equal to\n",
    "@show a < b       # less  \n",
    "@show a <= b ;    # less than or equal to"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, however that `==` implements exact numerical equality:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 / 3 = 0.6666666666666666\n",
      "2 // 3 = 2//3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@show 2/3\n",
    "@show 2//3\n",
    "2/3 == 2//3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectors, Matrices and Arrays\n",
    "\n",
    "Similar to Matlab, Julia has native support for vectors, matrices and tensors; all of which are represented by arrays of different dimensions.\n",
    "\n",
    "Vectors are constructed by comma-separated elements surrounded by square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 5\n",
       " 6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b = [5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{Float64}:\n",
       "  1.0\n",
       "  5.2\n",
       " -2.1\n",
       "  7.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "[1.0, 5.2, -2.1, 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a[1]  # => 1  # remember that Julia indexes from 1, not 0\n",
    "# a[0]      # BoundsError\n",
    "# end is a shorthand for the last index.\n",
    "a[end]  # => 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a1 = 1:5 = 1:5\n",
      "a = [1:5;] = [1, 2, 3, 4, 5]\n",
      "a[1:3] = [1, 2, 3]\n",
      "a[2:end] = [2, 3, 4, 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4-element Vector{Int64}:\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# You can initialize arrays from ranges\n",
    "@show a1 = 1:5 ; # => UnitRange{Int64}: 1:5\n",
    "@show a = [1:5;]  # => 5-element Array{Int64,1}: [1,2,3,4,5]\n",
    "\n",
    "# You can look at ranges with slice syntax.\n",
    "@show a[1:3]    # => [1, 2, 3]\n",
    "@show a[2:end]  # => [2, 3, 4, 5] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrices can be constructed with spaces separating the columns, and semicolons separating the rows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Matrix{Int64}:\n",
       " 1  2\n",
       " 3  4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "A = [1 2; 3 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int8}:\n",
       " 4\n",
       " 5\n",
       " 6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Arrays of a particular type\n",
    "b = Int8[4, 5, 6] # => 3-element Array{Int8,1}: [4, 5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "append!(a, b) = [1, 2, 4, 3, 4, 5, 6]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int8}:\n",
       " 4\n",
       " 5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = Int64[] # => 0-element Array{Int64,1}\n",
    "\n",
    "# Add stuff to the end of a vector with push! and append!\n",
    "# By convention, the exclamation mark '!' is appended to names of functions\n",
    "# that modify their arguments\n",
    "push!(a, 1)    # => [1]\n",
    "push!(a, 2)    # => [1,2]\n",
    "push!(a, 4)    # => [1,2,4]\n",
    "push!(a, 3)    # => [1,2,4,3]\n",
    "@show append!(a, b)  # => [1,2,4,3,4,5,6]\n",
    "# Remove from the end with pop\n",
    "pop!(b)  # => 6\n",
    "b # => [4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6-element Vector{Int64}:\n",
       " 2\n",
       " 4\n",
       " 3\n",
       " 4\n",
       " 5\n",
       " 6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = [1,2,4,3,4,5,6]\n",
    "# we also have popfirst! and pushfirst!\n",
    "popfirst!(a)  # => 1 \n",
    "a # => [2,4,3,4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pushfirst!(a, 7) = [7, 2, 4, 3, 4, 5, 6]\n",
      "a = [7, 2, 4, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "@show pushfirst!(a, 7) \n",
    "@show a ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr = [5, 4, 6] = [5, 4, 6]\n",
      "sort(arr) = [4, 5, 6]\n",
      "arr = [5, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "# Function names that end in exclamations points indicate that they modify\n",
    "# their argument.\n",
    "@show arr = [5,4,6]  # => 3-element Array{Int64,1}: [5,4,6]\n",
    "@show sort(arr)\n",
    "@show arr;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sort!(arr) = [4, 5, 6]\n",
      "arr = [4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "@show sort!(arr)\n",
    "@show arr ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that when multiplying vectors and matrices, dimensions matter. For example, you can't multiply a vector by a vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching *(::Vector{Int8}, ::Vector{Int8})\n\nClosest candidates are:\n  *(::Any, ::Any, !Matched::Any, !Matched::Any...)\n   @ Base operators.jl:578\n  *(!Matched::StridedMatrix{T}, ::StridedVector{S}) where {T<:Union{Float32, Float64, ComplexF32, ComplexF64}, S<:Real}\n   @ LinearAlgebra /Applications/Julia-1.9.app/Contents/Resources/julia/share/julia/stdlib/v1.9/LinearAlgebra/src/matmul.jl:49\n  *(::StridedVecOrMat, !Matched::LinearAlgebra.Adjoint{<:Any, <:LinearAlgebra.LQPackedQ})\n   @ LinearAlgebra /Applications/Julia-1.9.app/Contents/Resources/julia/share/julia/stdlib/v1.9/LinearAlgebra/src/lq.jl:269\n  ...\n",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching *(::Vector{Int8}, ::Vector{Int8})\n",
      "\n",
      "Closest candidates are:\n",
      "  *(::Any, ::Any, !Matched::Any, !Matched::Any...)\n",
      "   @ Base operators.jl:578\n",
      "  *(!Matched::StridedMatrix{T}, ::StridedVector{S}) where {T<:Union{Float32, Float64, ComplexF32, ComplexF64}, S<:Real}\n",
      "   @ LinearAlgebra /Applications/Julia-1.9.app/Contents/Resources/julia/share/julia/stdlib/v1.9/LinearAlgebra/src/matmul.jl:49\n",
      "  *(::StridedVecOrMat, !Matched::LinearAlgebra.Adjoint{<:Any, <:LinearAlgebra.LQPackedQ})\n",
      "   @ LinearAlgebra /Applications/Julia-1.9.app/Contents/Resources/julia/share/julia/stdlib/v1.9/LinearAlgebra/src/lq.jl:269\n",
      "  ...\n",
      "\n",
      "\n",
      "Stacktrace:\n",
      " [1] top-level scope\n",
      "   @ ~/Documents/MAE_ENE_539/power-systems-optimization/Tutorials/julia_tutorial.ipynb:1"
     ]
    }
   ],
   "source": [
    "b * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But multiplying transposes works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×2 adjoint(::Vector{Int8}) with eltype Int8:\n",
       " 4  5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b' * b = 41\n",
      "b * b' = Int8[16 20; 20 25]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2×2 Matrix{Int8}:\n",
       " 16  20\n",
       " 20  25"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@show b' * b    # i.e., inner product\n",
    "@show b * b'    # i.e., outer product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Broadcasting\n",
    "Element-by-element binary operations on arrays of different sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a .+ b = [7.0, 4.0, 9.0, 6.0]\n",
      "a .* b = [10.0, 3.0, 20.0, 5.0]\n",
      "convert.(Float32, [1, 2]) = Float32[1.0, 2.0]\n",
      "exp.(a) = [148.4131591025766, 2.718281828459045, 148.4131591025766, 2.718281828459045]\n"
     ]
    }
   ],
   "source": [
    "a = [5,1,5.,1]; b = [2,3,4,5];\n",
    "\n",
    "@show a .+ b\n",
    "@show a .* b\n",
    "\n",
    "@show convert.(Float32, [1, 2])\n",
    "@show exp.(a) ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do linear algebra: (e.g., solve the linear system Ax = b):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Float64}:\n",
       " -3.0\n",
       "  3.5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = A \\ b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Float64}:\n",
       " 4.0\n",
       " 5.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "A * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "A * x == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Julia makes extensive use of a simple data structure called Tuples.  Tuples are immutable collections of values.\n",
    "\n",
    "For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"hello\", 1.2, π)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = (\"hello\", 1.2, π)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Tuple{String, Float64, Irrational{:π}}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples can be accessed by index, similar to arrays,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And can be \"unpacked\" like so,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = \"hello\"\n",
      "b = 1.2\n",
      "c = π\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "π = 3.1415926535897..."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a, b, c = t\n",
    "@show a b c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d = 5\n",
      "e = 4\n"
     ]
    }
   ],
   "source": [
    "# Easy to swap two values\n",
    "d = 4; e = 5;\n",
    "e, d = d, e  # => (5,4) \n",
    "@show d  # => 5\n",
    "@show e ; # => 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The values can also be given names, which is a convenient way of making light-weight data structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(word = \"hello\", num = 1.2, sym = :foo)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = (word=\"hello\", num=1.2, sym=:foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then values can be accessed using a dot syntax,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"hello\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t.word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "Similar to Python, Julia has native support for dictionaries.  Dictionaries provide a very generic way of mapping keys to values.  For example, a map of strings to integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String, Int64} with 3 entries:\n",
       "  \"B\" => 2\n",
       "  \"A\" => 1\n",
       "  \"D\" => 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "d1 = Dict(\"A\" => 1, \"B\" => 2, \"D\" => 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking up values uses the bracket syntax,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "d1[\"B\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries can be nested"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String, Any} with 3 entries:\n",
       "  \"B\" => 2\n",
       "  \"A\" => 1\n",
       "  \"D\" => Dict(:bar=>4, :foo=>3)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "d2 = Dict(\"A\" => 1, \"B\" => 2, \"D\" => Dict(:foo => 3, :bar => 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "keys(d2) = [\"B\", \"A\", \"D\"]\n",
      "haskey(d2, \"A\") = true\n",
      "haskey(d2, 1) = false\n"
     ]
    }
   ],
   "source": [
    "# Get all keys\n",
    "@show keys(d2)\n",
    "@show haskey(d2, \"A\")     # => true\n",
    "@show haskey(d2, 1);       # => false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ValueIterator for a Dict{String, Any} with 3 entries. Values:\n",
       "  2\n",
       "  1\n",
       "  Dict(:bar => 4, :foo => 3)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get all values\n",
    "values(d2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "Sets are used to represent collections of unordered, unique values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set{Int64} with 4 elements:\n",
       "  4\n",
       "  2\n",
       "  3\n",
       "  1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "emptySet = Set()  # => Set(Any[])\n",
    "# Initialize a set with values\n",
    "filledSet = Set([1, 2, 2, 3, 4])  # => Set([4, 2, 3, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set{Int64} with 5 elements:\n",
       "  5\n",
       "  4\n",
       "  2\n",
       "  3\n",
       "  1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Add more values to a set\n",
    "push!(filledSet, 5)  # => Set([4, 2, 3, 5, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 in filledSet = true\n",
      "10 in filledSet = false\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@show 2 in filledSet\n",
    "@show 10 in filledSet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are functions for set intersection, union, and difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "intersect(filledSet, otherSet) = Set([4, 3])\n",
      "union(filledSet, otherSet) = Set([5, 4, 6, 2, 3, 1])\n",
      "setdiff(Set([1, 2, 3, 4]), Set([2, 3, 5])) = Set([4, 1])\n"
     ]
    }
   ],
   "source": [
    "filledSet = Set([1, 2, 2, 3, 4])            # => Set([4, 2, 3, 1])\n",
    "otherSet = Set([3, 4, 5, 6])                # => Set([4, 3, 5, 6])\n",
    "@show intersect(filledSet, otherSet)        # => Set([4, 3, 5])\n",
    "@show union(filledSet, otherSet)            # => Set([4, 2, 3, 5, 6, 1])\n",
    "@show setdiff(Set([1,2,3,4]),Set([2,3,5])); # => Set([4, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataframes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tools for working with tabular data in Julia. (See [DataFrames.jl](https://github.com/JuliaData/DataFrames.jl/tree/main)).\n",
    "\n",
    "You can create a DataFrame in many ways: using a `Constructor`, from a Julia `dict`, `NamedTuple`s, `matrix`, or by reading data from a CSV file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>3×3 DataFrame</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">A</th><th style = \"text-align: left;\">B</th><th style = \"text-align: left;\">fixed</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">5</td><td style = \"text-align: right;\">1</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">6</td><td style = \"text-align: right;\">1</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">3</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">7</td><td style = \"text-align: right;\">1</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|ccc}\n",
       "\t& A & B & fixed\\\\\n",
       "\t\\hline\n",
       "\t& Int64 & Int64 & Int64\\\\\n",
       "\t\\hline\n",
       "\t1 & 1 & 5 & 1 \\\\\n",
       "\t2 & 2 & 6 & 1 \\\\\n",
       "\t3 & 3 & 7 & 1 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m3×3 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m A     \u001b[0m\u001b[1m B     \u001b[0m\u001b[1m fixed \u001b[0m\n",
       "     │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\n",
       "─────┼─────────────────────\n",
       "   1 │     1      5      1\n",
       "   2 │     2      6      1\n",
       "   3 │     3      7      1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "using CSV\n",
    "using DataFrames\n",
    "\n",
    "df = DataFrame(A=1:3, B=5:7, fixed=1)   # constructor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>3×2 DataFrame</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">customer_age</th><th style = \"text-align: left;\">first_name</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"String\" style = \"text-align: left;\">String</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: right;\">15</td><td style = \"text-align: left;\">Rohit</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: right;\">20</td><td style = \"text-align: left;\">Rahul</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">3</td><td style = \"text-align: right;\">25</td><td style = \"text-align: left;\">Akshat</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cc}\n",
       "\t& customer\\_age & first\\_name\\\\\n",
       "\t\\hline\n",
       "\t& Int64 & String\\\\\n",
       "\t\\hline\n",
       "\t1 & 15 & Rohit \\\\\n",
       "\t2 & 20 & Rahul \\\\\n",
       "\t3 & 25 & Akshat \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m3×2 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m customer_age \u001b[0m\u001b[1m first_name \u001b[0m\n",
       "     │\u001b[90m Int64        \u001b[0m\u001b[90m String     \u001b[0m\n",
       "─────┼──────────────────────────\n",
       "   1 │           15  Rohit\n",
       "   2 │           20  Rahul\n",
       "   3 │           25  Akshat"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dict = Dict(:customer_age => [15, 20, 25],\n",
    "            :first_name => [\"Rohit\", \"Rahul\", \"Akshat\"])\n",
    "df =  DataFrame(dict)   # from dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>3×4 DataFrame</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">a</th><th style = \"text-align: left;\">b</th><th style = \"text-align: left;\">c</th><th style = \"text-align: left;\">d</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">5</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: right;\">15</td><td style = \"text-align: right;\">58</td><td style = \"text-align: right;\">69</td><td style = \"text-align: right;\">41</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">3</td><td style = \"text-align: right;\">23</td><td style = \"text-align: right;\">21</td><td style = \"text-align: right;\">26</td><td style = \"text-align: right;\">69</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cccc}\n",
       "\t& a & b & c & d\\\\\n",
       "\t\\hline\n",
       "\t& Int64 & Int64 & Int64 & Int64\\\\\n",
       "\t\\hline\n",
       "\t1 & 1 & 2 & 4 & 5 \\\\\n",
       "\t2 & 15 & 58 & 69 & 41 \\\\\n",
       "\t3 & 23 & 21 & 26 & 69 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m3×4 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m a     \u001b[0m\u001b[1m b     \u001b[0m\u001b[1m c     \u001b[0m\u001b[1m d     \u001b[0m\n",
       "     │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\n",
       "─────┼────────────────────────────\n",
       "   1 │     1      2      4      5\n",
       "   2 │    15     58     69     41\n",
       "   3 │    23     21     26     69"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mat = [1 2 4 5; 15 58 69 41; 23 21 26 69]\n",
    "header = [\"a\", \"b\", \"c\", \"d\"]\n",
    "df = DataFrame(mat, header)     # from matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>96×5 DataFrame</span></div><div style = \"float: right;\"><span style = \"font-style: italic;\">71 rows omitted</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">T</th><th style = \"text-align: left;\">Hour</th><th style = \"text-align: left;\">Interval</th><th style = \"text-align: left;\">Price</th><th style = \"text-align: left;\">Solar</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">12.77</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">11.82</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">3</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">12.39</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">4</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">10.17</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">5</td><td style = \"text-align: right;\">5</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">5.86</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">6</td><td style = \"text-align: right;\">6</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">2.69</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">7</td><td style = \"text-align: right;\">7</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">1.46</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">8</td><td style = \"text-align: right;\">8</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">1.41</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">9</td><td style = \"text-align: right;\">9</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">0.03</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">10</td><td style = \"text-align: right;\">10</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">-0.19</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">11</td><td style = \"text-align: right;\">11</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">-0.72</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">12</td><td style = \"text-align: right;\">12</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">-0.54</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">13</td><td style = \"text-align: right;\">13</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">-0.45</td><td style = \"text-align: right;\">0.0</td></tr><tr><td style = \"text-align: right;\">&vellip;</td><td style = \"text-align: right;\">&vellip;</td><td style = \"text-align: right;\">&vellip;</td><td style = \"text-align: right;\">&vellip;</td><td style = \"text-align: right;\">&vellip;</td><td style = \"text-align: right;\">&vellip;</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">85</td><td style = \"text-align: right;\">85</td><td style = \"text-align: right;\">22</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">16.86</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">86</td><td style = \"text-align: right;\">86</td><td style = \"text-align: right;\">22</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">14.43</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">87</td><td style = \"text-align: right;\">87</td><td style = \"text-align: right;\">22</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">12.47</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">88</td><td style = \"text-align: right;\">88</td><td style = \"text-align: right;\">22</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">13.11</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">89</td><td style = \"text-align: right;\">89</td><td style = \"text-align: right;\">23</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">17.61</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">90</td><td style = \"text-align: right;\">90</td><td style = \"text-align: right;\">23</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">16.16</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">91</td><td style = \"text-align: right;\">91</td><td style = \"text-align: right;\">23</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">15.3</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">92</td><td style = \"text-align: right;\">92</td><td style = \"text-align: right;\">23</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">15.18</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">93</td><td style = \"text-align: right;\">93</td><td style = \"text-align: right;\">24</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">13.61</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">94</td><td style = \"text-align: right;\">94</td><td style = \"text-align: right;\">24</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">11.89</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">95</td><td style = \"text-align: right;\">95</td><td style = \"text-align: right;\">24</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">14.23</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">96</td><td style = \"text-align: right;\">96</td><td style = \"text-align: right;\">24</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">14.09</td><td style = \"text-align: right;\">0.0</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|ccccc}\n",
       "\t& T & Hour & Interval & Price & Solar\\\\\n",
       "\t\\hline\n",
       "\t& Int64 & Int64 & Int64 & Float64 & Float64\\\\\n",
       "\t\\hline\n",
       "\t1 & 1 & 1 & 1 & 12.77 & 0.0 \\\\\n",
       "\t2 & 2 & 1 & 2 & 11.82 & 0.0 \\\\\n",
       "\t3 & 3 & 1 & 3 & 12.39 & 0.0 \\\\\n",
       "\t4 & 4 & 1 & 4 & 10.17 & 0.0 \\\\\n",
       "\t5 & 5 & 2 & 1 & 5.86 & 0.0 \\\\\n",
       "\t6 & 6 & 2 & 2 & 2.69 & 0.0 \\\\\n",
       "\t7 & 7 & 2 & 3 & 1.46 & 0.0 \\\\\n",
       "\t8 & 8 & 2 & 4 & 1.41 & 0.0 \\\\\n",
       "\t9 & 9 & 3 & 1 & 0.03 & 0.0 \\\\\n",
       "\t10 & 10 & 3 & 2 & -0.19 & 0.0 \\\\\n",
       "\t11 & 11 & 3 & 3 & -0.72 & 0.0 \\\\\n",
       "\t12 & 12 & 3 & 4 & -0.54 & 0.0 \\\\\n",
       "\t13 & 13 & 4 & 1 & -0.45 & 0.0 \\\\\n",
       "\t14 & 14 & 4 & 2 & -0.6 & 0.0 \\\\\n",
       "\t15 & 15 & 4 & 3 & -0.72 & 0.0 \\\\\n",
       "\t16 & 16 & 4 & 4 & -0.63 & 0.0 \\\\\n",
       "\t17 & 17 & 5 & 1 & -0.72 & 0.0 \\\\\n",
       "\t18 & 18 & 5 & 2 & -1.19 & 0.0 \\\\\n",
       "\t19 & 19 & 5 & 3 & -1.04 & 0.0 \\\\\n",
       "\t20 & 20 & 5 & 4 & -0.76 & 0.0 \\\\\n",
       "\t21 & 21 & 6 & 1 & -0.47 & 0.0 \\\\\n",
       "\t22 & 22 & 6 & 2 & 0.68 & 0.0 \\\\\n",
       "\t23 & 23 & 6 & 3 & 0.78 & 0.0 \\\\\n",
       "\t24 & 24 & 6 & 4 & 0.09 & 0.0 \\\\\n",
       "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m96×5 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m T     \u001b[0m\u001b[1m Hour  \u001b[0m\u001b[1m Interval \u001b[0m\u001b[1m Price   \u001b[0m\u001b[1m Solar   \u001b[0m\n",
       "     │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64    \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n",
       "─────┼──────────────────────────────────────────\n",
       "   1 │     1      1         1    12.77      0.0\n",
       "   2 │     2      1         2    11.82      0.0\n",
       "   3 │     3      1         3    12.39      0.0\n",
       "   4 │     4      1         4    10.17      0.0\n",
       "   5 │     5      2         1     5.86      0.0\n",
       "   6 │     6      2         2     2.69      0.0\n",
       "   7 │     7      2         3     1.46      0.0\n",
       "   8 │     8      2         4     1.41      0.0\n",
       "  ⋮  │   ⋮      ⋮       ⋮         ⋮        ⋮\n",
       "  90 │    90     23         2    16.16      0.0\n",
       "  91 │    91     23         3    15.3       0.0\n",
       "  92 │    92     23         4    15.18      0.0\n",
       "  93 │    93     24         1    13.61      0.0\n",
       "  94 │    94     24         2    11.89      0.0\n",
       "  95 │    95     24         3    14.23      0.0\n",
       "  96 │    96     24         4    14.09      0.0\n",
       "\u001b[36m                                 81 rows omitted\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = DataFrame(CSV.File(\"../Notebooks/anatomy_data/solar_battery_data.csv\"))     # from CSV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To extract the columns of a `DataFrame` directly (i.e. without copying) you can use one of the following syntaxes: `df.T`, `df.\"T\"`, `df[!, :T]` or `df[!, \"T\"]` (a copy is made when usign `df[:,T]`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "96-element Vector{Int64}:\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  4\n",
       "  5\n",
       "  6\n",
       "  7\n",
       "  8\n",
       "  9\n",
       " 10\n",
       "  ⋮\n",
       " 88\n",
       " 89\n",
       " 90\n",
       " 91\n",
       " 92\n",
       " 93\n",
       " 94\n",
       " 95\n",
       " 96"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.\"T\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can obtain a vector of column names of the data frame as `Strings` using the `names` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{String}:\n",
       " \"T\"\n",
       " \"Hour\"\n",
       " \"Interval\"\n",
       " \"Price\"\n",
       " \"Solar\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "names(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you were interested in element types of the columns, you can use the `eachcol` function to iterate over the columns, and `eltype` function to get the desired output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{DataType}:\n",
       " Int64\n",
       " Int64\n",
       " Int64\n",
       " Float64\n",
       " Float64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "eltype.(eachcol(df))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other useful function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size(df) = (96, 5)\n",
      "size(df, 1) = 96\n",
      "size(df, 2) = 5\n",
      "nrow(df) = 96\n",
      "ncol(df) = 5\n",
      "describe(df) = 5×7 DataFrame\n",
      " Row │ variable  mean     min    median   max    nmissing  eltype\n",
      "     │ Symbol    Float64  Real   Float64  Real   Int64     DataType\n",
      "─────┼──────────────────────────────────────────────────────────────\n",
      "   1 │ T         48.5      1       48.5   96            0  Int64\n",
      "   2 │ Hour      12.5      1       12.5   24            0  Int64\n",
      "   3 │ Interval   2.5      1        2.5    4            0  Int64\n",
      "   4 │ Price     15.4707  -1.19    13.97  77.85         0  Float64\n",
      "   5 │ Solar     16.8261   0.0      0.0   50.0          0  Float64\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>5×7 DataFrame</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">variable</th><th style = \"text-align: left;\">mean</th><th style = \"text-align: left;\">min</th><th style = \"text-align: left;\">median</th><th style = \"text-align: left;\">max</th><th style = \"text-align: left;\">nmissing</th><th style = \"text-align: left;\">eltype</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Symbol\" style = \"text-align: left;\">Symbol</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th><th title = \"Real\" style = \"text-align: left;\">Real</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th><th title = \"Real\" style = \"text-align: left;\">Real</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"DataType\" style = \"text-align: left;\">DataType</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: left;\">T</td><td style = \"text-align: right;\">48.5</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">48.5</td><td style = \"text-align: right;\">96</td><td style = \"text-align: right;\">0</td><td style = \"text-align: left;\">Int64</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: left;\">Hour</td><td style = \"text-align: right;\">12.5</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">12.5</td><td style = \"text-align: right;\">24</td><td style = \"text-align: right;\">0</td><td style = \"text-align: left;\">Int64</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">3</td><td style = \"text-align: left;\">Interval</td><td style = \"text-align: right;\">2.5</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">2.5</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">0</td><td style = \"text-align: left;\">Int64</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">4</td><td style = \"text-align: left;\">Price</td><td style = \"text-align: right;\">15.4707</td><td style = \"text-align: right;\">-1.19</td><td style = \"text-align: right;\">13.97</td><td style = \"text-align: right;\">77.85</td><td style = \"text-align: right;\">0</td><td style = \"text-align: left;\">Float64</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">5</td><td style = \"text-align: left;\">Solar</td><td style = \"text-align: right;\">16.8261</td><td style = \"text-align: right;\">0.0</td><td style = \"text-align: right;\">0.0</td><td style = \"text-align: right;\">50.0</td><td style = \"text-align: right;\">0</td><td style = \"text-align: left;\">Float64</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|ccccccc}\n",
       "\t& variable & mean & min & median & max & nmissing & eltype\\\\\n",
       "\t\\hline\n",
       "\t& Symbol & Float64 & Real & Float64 & Real & Int64 & DataType\\\\\n",
       "\t\\hline\n",
       "\t1 & T & 48.5 & 1 & 48.5 & 96 & 0 & Int64 \\\\\n",
       "\t2 & Hour & 12.5 & 1 & 12.5 & 24 & 0 & Int64 \\\\\n",
       "\t3 & Interval & 2.5 & 1 & 2.5 & 4 & 0 & Int64 \\\\\n",
       "\t4 & Price & 15.4707 & -1.19 & 13.97 & 77.85 & 0 & Float64 \\\\\n",
       "\t5 & Solar & 16.8261 & 0.0 & 0.0 & 50.0 & 0 & Float64 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m5×7 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m variable \u001b[0m\u001b[1m mean    \u001b[0m\u001b[1m min   \u001b[0m\u001b[1m median  \u001b[0m\u001b[1m max   \u001b[0m\u001b[1m nmissing \u001b[0m\u001b[1m eltype   \u001b[0m\n",
       "     │\u001b[90m Symbol   \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Real  \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Real  \u001b[0m\u001b[90m Int64    \u001b[0m\u001b[90m DataType \u001b[0m\n",
       "─────┼──────────────────────────────────────────────────────────────\n",
       "   1 │ T         48.5      1       48.5   96            0  Int64\n",
       "   2 │ Hour      12.5      1       12.5   24            0  Int64\n",
       "   3 │ Interval   2.5      1        2.5    4            0  Int64\n",
       "   4 │ Price     15.4707  -1.19    13.97  77.85         0  Float64\n",
       "   5 │ Solar     16.8261   0.0      0.0   50.0          0  Float64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_copy = copy(df)\n",
    "empty_df = empty(df)    # returns an empty dataframe with same column names and types, but with zero rows\n",
    "empty!(df_copy)  # remove all rows from df_copy in-place\n",
    "\n",
    "@show size(df)  # dataframe dimensions\n",
    "@show size(df, 1)   # dataframe dimension along first axis\n",
    "@show size(df, 2)   # dataframe dimension along second axis\n",
    "@show nrow(df)  # number of rows\n",
    "@show ncol(df)  # number of columns\n",
    "describe(df)  # get basis statistcs of data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>6×5 DataFrame</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">T</th><th style = \"text-align: left;\">Hour</th><th style = \"text-align: left;\">Interval</th><th style = \"text-align: left;\">Price</th><th style = \"text-align: left;\">Solar</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">12.77</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">11.82</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">3</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">12.39</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">4</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">10.17</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">5</td><td style = \"text-align: right;\">5</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">5.86</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">6</td><td style = \"text-align: right;\">6</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">2.69</td><td style = \"text-align: right;\">0.0</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|ccccc}\n",
       "\t& T & Hour & Interval & Price & Solar\\\\\n",
       "\t\\hline\n",
       "\t& Int64 & Int64 & Int64 & Float64 & Float64\\\\\n",
       "\t\\hline\n",
       "\t1 & 1 & 1 & 1 & 12.77 & 0.0 \\\\\n",
       "\t2 & 2 & 1 & 2 & 11.82 & 0.0 \\\\\n",
       "\t3 & 3 & 1 & 3 & 12.39 & 0.0 \\\\\n",
       "\t4 & 4 & 1 & 4 & 10.17 & 0.0 \\\\\n",
       "\t5 & 5 & 2 & 1 & 5.86 & 0.0 \\\\\n",
       "\t6 & 6 & 2 & 2 & 2.69 & 0.0 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m6×5 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m T     \u001b[0m\u001b[1m Hour  \u001b[0m\u001b[1m Interval \u001b[0m\u001b[1m Price   \u001b[0m\u001b[1m Solar   \u001b[0m\n",
       "     │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64    \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n",
       "─────┼──────────────────────────────────────────\n",
       "   1 │     1      1         1    12.77      0.0\n",
       "   2 │     2      1         2    11.82      0.0\n",
       "   3 │     3      1         3    12.39      0.0\n",
       "   4 │     4      1         4    10.17      0.0\n",
       "   5 │     5      2         1     5.86      0.0\n",
       "   6 │     6      2         2     2.69      0.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "first(df,6) # first 6 rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>6×5 DataFrame</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">T</th><th style = \"text-align: left;\">Hour</th><th style = \"text-align: left;\">Interval</th><th style = \"text-align: left;\">Price</th><th style = \"text-align: left;\">Solar</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: right;\">91</td><td style = \"text-align: right;\">23</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">15.3</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: right;\">92</td><td style = \"text-align: right;\">23</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">15.18</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">3</td><td style = \"text-align: right;\">93</td><td style = \"text-align: right;\">24</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">13.61</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">4</td><td style = \"text-align: right;\">94</td><td style = \"text-align: right;\">24</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">11.89</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">5</td><td style = \"text-align: right;\">95</td><td style = \"text-align: right;\">24</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">14.23</td><td style = \"text-align: right;\">0.0</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">6</td><td style = \"text-align: right;\">96</td><td style = \"text-align: right;\">24</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">14.09</td><td style = \"text-align: right;\">0.0</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|ccccc}\n",
       "\t& T & Hour & Interval & Price & Solar\\\\\n",
       "\t\\hline\n",
       "\t& Int64 & Int64 & Int64 & Float64 & Float64\\\\\n",
       "\t\\hline\n",
       "\t1 & 91 & 23 & 3 & 15.3 & 0.0 \\\\\n",
       "\t2 & 92 & 23 & 4 & 15.18 & 0.0 \\\\\n",
       "\t3 & 93 & 24 & 1 & 13.61 & 0.0 \\\\\n",
       "\t4 & 94 & 24 & 2 & 11.89 & 0.0 \\\\\n",
       "\t5 & 95 & 24 & 3 & 14.23 & 0.0 \\\\\n",
       "\t6 & 96 & 24 & 4 & 14.09 & 0.0 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m6×5 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m T     \u001b[0m\u001b[1m Hour  \u001b[0m\u001b[1m Interval \u001b[0m\u001b[1m Price   \u001b[0m\u001b[1m Solar   \u001b[0m\n",
       "     │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64    \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n",
       "─────┼──────────────────────────────────────────\n",
       "   1 │    91     23         3    15.3       0.0\n",
       "   2 │    92     23         4    15.18      0.0\n",
       "   3 │    93     24         1    13.61      0.0\n",
       "   4 │    94     24         2    11.89      0.0\n",
       "   5 │    95     24         3    14.23      0.0\n",
       "   6 │    96     24         4    14.09      0.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "last(df,6)  # last 6 rows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing a `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>2×2 DataFrame</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">A</th><th style = \"text-align: left;\">fixed</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">1</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">1</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cc}\n",
       "\t& A & fixed\\\\\n",
       "\t\\hline\n",
       "\t& Int64 & Int64\\\\\n",
       "\t\\hline\n",
       "\t1 & 1 & 1 \\\\\n",
       "\t2 & 2 & 1 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m2×2 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m A     \u001b[0m\u001b[1m fixed \u001b[0m\n",
       "     │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\n",
       "─────┼──────────────\n",
       "   1 │     1      1\n",
       "   2 │     2      1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df2 = df[1:2, [1,3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>3×4 DataFrame</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">T</th><th style = \"text-align: left;\">Hour</th><th style = \"text-align: left;\">Interval</th><th style = \"text-align: left;\">Price</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">12.77</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">11.82</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">3</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">12.39</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cccc}\n",
       "\t& T & Hour & Interval & Price\\\\\n",
       "\t\\hline\n",
       "\t& Int64 & Int64 & Int64 & Float64\\\\\n",
       "\t\\hline\n",
       "\t1 & 1 & 1 & 1 & 12.77 \\\\\n",
       "\t2 & 2 & 1 & 2 & 11.82 \\\\\n",
       "\t3 & 3 & 1 & 3 & 12.39 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m3×4 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m T     \u001b[0m\u001b[1m Hour  \u001b[0m\u001b[1m Interval \u001b[0m\u001b[1m Price   \u001b[0m\n",
       "     │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64    \u001b[0m\u001b[90m Float64 \u001b[0m\n",
       "─────┼─────────────────────────────────\n",
       "   1 │     1      1         1    12.77\n",
       "   2 │     2      1         2    11.82\n",
       "   3 │     3      1         3    12.39"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df1 = df[1:3, 1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Changing the data stored in a `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div style = \"float: left;\"><span>3×4 DataFrame</span></div><div style = \"clear: both;\"></div></div><div class = \"data-frame\" style = \"overflow-x: scroll;\"><table class = \"data-frame\" style = \"margin-bottom: 6px;\"><thead><tr class = \"header\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">Row</th><th style = \"text-align: left;\">T</th><th style = \"text-align: left;\">Hour</th><th style = \"text-align: left;\">Interval</th><th style = \"text-align: left;\">Price</th></tr><tr class = \"subheader headerLastRow\"><th class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\"></th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Int64\" style = \"text-align: left;\">Int64</th><th title = \"Float64\" style = \"text-align: left;\">Float64</th></tr></thead><tbody><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">1</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">1</td><td style = \"text-align: right;\">12.77</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">2</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">4</td><td style = \"text-align: right;\">2</td><td style = \"text-align: right;\">11.82</td></tr><tr><td class = \"rowNumber\" style = \"font-weight: bold; text-align: right;\">3</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">5</td><td style = \"text-align: right;\">3</td><td style = \"text-align: right;\">12.39</td></tr></tbody></table></div>"
      ],
      "text/latex": [
       "\\begin{tabular}{r|cccc}\n",
       "\t& T & Hour & Interval & Price\\\\\n",
       "\t\\hline\n",
       "\t& Int64 & Int64 & Int64 & Float64\\\\\n",
       "\t\\hline\n",
       "\t1 & 1 & 3 & 1 & 12.77 \\\\\n",
       "\t2 & 2 & 4 & 2 & 11.82 \\\\\n",
       "\t3 & 3 & 5 & 3 & 12.39 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "\u001b[1m3×4 DataFrame\u001b[0m\n",
       "\u001b[1m Row \u001b[0m│\u001b[1m T     \u001b[0m\u001b[1m Hour  \u001b[0m\u001b[1m Interval \u001b[0m\u001b[1m Price   \u001b[0m\n",
       "     │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64    \u001b[0m\u001b[90m Float64 \u001b[0m\n",
       "─────┼─────────────────────────────────\n",
       "   1 │     1      3         1    12.77\n",
       "   2 │     2      4         2    11.82\n",
       "   3 │     3      5         3    12.39"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "new_val = [3,4,5]\n",
    "df1.Hour = new_val\n",
    "df1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control-flow: Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For-Each Loops\n",
    "\n",
    "Julia has native support for for-each style loops with the syntax `for <value> in <collection> end`.\n",
    "Iterable types include `Range`, `Array`, `Set`, `Dict`, and `AbstractString`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in 1:5\n",
    "    println(i)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2\n",
      "2.3\n",
      "3.4\n",
      "4.5\n",
      "5.6\n"
     ]
    }
   ],
   "source": [
    "for i in [1.2, 2.3, 3.4, 4.5, 5.6]\n",
    "    println(i)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This for-each loop also works with dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B: 2.5\n",
      "A: 1\n",
      "D: 2 - 3im\n"
     ]
    }
   ],
   "source": [
    "for (key, value) in Dict(\"A\" => 1, \"B\" => 2.5, \"D\" => 2 - 3im)\n",
    "    println(\"$key: $value\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i: 1\t j: 1\t i*j: 1*1\n",
      "i: 1\t j: 2\t i*j: 1*2\n",
      "i: 1\t j: 3\t i*j: 1*3\n",
      "i: 1\t j: 4\t i*j: 1*4\n",
      "i: 1\t j: 5\t i*j: 1*5\n",
      "i: 2\t j: 1\t i*j: 2*1\n",
      "i: 2\t j: 2\t i*j: 2*2\n",
      "i: 2\t j: 3\t i*j: 2*3\n",
      "i: 2\t j: 4\t i*j: 2*4\n",
      "i: 2\t j: 5\t i*j: 2*5\n",
      "i: 3\t j: 1\t i*j: 3*1\n",
      "i: 3\t j: 2\t i*j: 3*2\n",
      "i: 3\t j: 3\t i*j: 3*3\n",
      "i: 3\t j: 4\t i*j: 3*4\n",
      "i: 3\t j: 5\t i*j: 3*5\n",
      "i: 4\t j: 1\t i*j: 4*1\n",
      "i: 4\t j: 2\t i*j: 4*2\n",
      "i: 4\t j: 3\t i*j: 4*3\n",
      "i: 4\t j: 4\t i*j: 4*4\n",
      "i: 4\t j: 5\t i*j: 4*5\n"
     ]
    }
   ],
   "source": [
    "# Unnested for loop\n",
    "for i in 1:4, j = 1:5\n",
    "    println(\"i: $i\\t j: $j\\t i*j: $i*$j\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in contrast to vector languages like Matlab and R, loops do not result in a significant performance degradation in Julia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### While-loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 4\n",
    "    println(x)\n",
    "    x += 1  # Shorthand for in place increment: x = x + 1\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control Flow - Conditionals\n",
    " \n",
    "Julia control flow is similar to Matlab, using the keywords `if-elseif-else-end`, and the logical operators `||` and `&&` for *or* and *and* respectively. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is less than 5\n",
      "3 is less than 5\n",
      "6 is less than 10\n",
      "9 is less than 10\n",
      "12 is bigger than 10\n",
      "15 is bigger than 10\n"
     ]
    }
   ],
   "source": [
    "for i in 0:3:15\n",
    "    if i < 5 \n",
    "        println(\"$(i) is less than 5\")\n",
    "    elseif i < 10\n",
    "        println(\"$(i) is less than 10\")\n",
    "    else\n",
    "        if i == 10\n",
    "            println(\"the value is 10\")\n",
    "        else\n",
    "            println(\"$(i) is bigger than 10\")\n",
    "        end\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comprehensions\n",
    "\n",
    "Similar to languages like Haskell and Python, Julia supports the use of simple loops in the construction of arrays and dictionaries, called comprehenions.\n",
    "\n",
    "A list of increasing integers,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "[i for i in 1:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrices can be built by including multiple indices,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×6 Matrix{Int64}:\n",
       "  5   6   7   8   9  10\n",
       " 10  12  14  16  18  20\n",
       " 15  18  21  24  27  30\n",
       " 20  24  28  32  36  40\n",
       " 25  30  35  40  45  50"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "[i*j for i in 1:5, j in 5:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A similar syntax can be used for building dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String, Int64} with 5 entries:\n",
       "  \"1\" => 1\n",
       "  \"5\" => 5\n",
       "  \"7\" => 7\n",
       "  \"9\" => 9\n",
       "  \"3\" => 3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Dict(\"$i\" => i for i in 1:10 if i%2 == 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditional statements can be used to filter out some values,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 1\n",
       " 3\n",
       " 5\n",
       " 7\n",
       " 9"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "[i for i in 1:10 if i%2 == 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "A simple function is defined as follows,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "function print_hello()\n",
    "    println(\"hello\")\n",
    "end\n",
    "print_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arguments can be added to a function,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "1.234\n"
     ]
    }
   ],
   "source": [
    "function print_it(x)\n",
    "    println(x)\n",
    "end\n",
    "\n",
    "print_it(\"hello\")\n",
    "print_it(1.234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 5 and y is 6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function add(x, y)\n",
    "    println(\"x is $x and y is $y\")\n",
    "\n",
    "    # Functions return the value of their last statement\n",
    "    return x + y\n",
    "end\n",
    "\n",
    "add(5, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with variables, Unicode can also be used for function names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "∑(x,y) = x + y\n",
    "\n",
    "∑(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword `return` is used to specify the return values of a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function mult(x; y=2.0)\n",
    "    return x * y\n",
    "end\n",
    "mult(4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mult(4.0, y=5.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compact assignment of functions (\"assignment form\"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f_add(x, y) = x + y  # => f_add (generic function with 1 method)\n",
    "f_add(3, 4)  # => 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function can also return multiple values as tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7, -1)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fn(x, y) = x + y, x - y # => fn (generic function with 1 method)\n",
    "fn(3, 4)  # => (7, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can define functions with optional positional arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "defaults(3, 5) = \"3 5 and 5 6\"\n",
      "defaults(3, 5, 2) = \"3 5 and 2 6\"\n",
      "defaults(3, 5, 2, 5) = \"3 5 and 2 5\"\n"
     ]
    }
   ],
   "source": [
    "function defaults(a, b, x=5, y=6)\n",
    "    return \"$a $b and $x $y\"\n",
    "end\n",
    "\n",
    "@show defaults(3,5)\n",
    "@show defaults(3,5,2)\n",
    "@show defaults(3,5,2,5) ;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optional keyword arguments are also possible "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value: 1.234\n",
      "val: 1.234\n"
     ]
    }
   ],
   "source": [
    "function print_it(x; prefix=\"value:\")\n",
    "    println(\"$(prefix) $x\")\n",
    "end\n",
    "print_it(1.234)\n",
    "print_it(1.234, prefix=\"Result:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are `built-in` higher order functions, like `map`, `filter`, which apply a function to a `collection`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 11\n",
       " 12\n",
       " 13"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_fun(x) = x + 10\n",
    "map(my_fun, [1,2,3])  # => [11, 12, 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 6\n",
       " 7"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "filter(x -> x > 5, [3, 4, 5, 6, 7])  # => [6, 7]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can be assigned to variables, passed into functions, returned from a functions (i.e., they are **first-class** objects in Julia) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function create_adder(x)\n",
    "    adder = function (y)\n",
    "        return x + y\n",
    "    end\n",
    "    return adder\n",
    "end\n",
    "\n",
    "param_add = create_adder(10)\n",
    "param_add(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ... is called a `splat`. It can be used in a function call, and in a function definition, where it will splat an Array or Tuple's contents into the argument list (automatically assigned as multiple function arguments)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: `add` not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: `add` not defined\n",
      "\n",
      "Stacktrace:\n",
      " [1] top-level scope\n",
      "   @ show.jl:1128"
     ]
    }
   ],
   "source": [
    "y = (5, 6)  # => (5,6)\n",
    "@show add(y...)  # this is equivalent to add(5,6)\n",
    "\n",
    "multiply(x...) = only(map(prod,x))\n",
    "@show multiply(y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutable vs immutable objects\n",
    "\n",
    "Some types in Julia are *mutable*, which means you can change the values inside them. A good example is an array. You can modify the contents of an array without having to make a new array.\n",
    "\n",
    "In contrast, types like `Float64` are *immutable*. You can't modify the contents of a `Float64`.\n",
    "\n",
    "This is something to be aware of when passing types into functions. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mutable_type: [2, 2, 3]\n",
      "immutable_type: 1\n"
     ]
    }
   ],
   "source": [
    "function mutability_example(mutable_type::Vector{Int}, immutable_type::Int)\n",
    "    mutable_type[1] += 1\n",
    "    immutable_type += 1\n",
    "    return\n",
    "end\n",
    "\n",
    "mutable_type = [1, 2, 3]\n",
    "immutable_type = 1\n",
    "\n",
    "mutability_example(mutable_type, immutable_type)\n",
    "\n",
    "println(\"mutable_type: $(mutable_type)\")\n",
    "println(\"immutable_type: $(immutable_type)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because `Vector{Int}` is a mutable type, modifying the variable inside the function changed the value outside of the function. In constrast, the change to `immutable_type` didn't modify the value outside the function.\n",
    "\n",
    "You can check mutability with the `isimmutable` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isimmutable([1, 2, 3]) = false\n",
      "isimmutable(1) = true\n"
     ]
    }
   ],
   "source": [
    "@show isimmutable([1, 2, 3])\n",
    "@show isimmutable(1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's code "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "Reverse an array in two different ways (one can be done using the function `reverse`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,4,5]\n",
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```julia\n",
    "a[end:-1:1] #faster\n",
    "```\n",
    "```julia\n",
    "reverse(a)\n",
    "```\n",
    "```julia\n",
    "reverse!(a) #inplace\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let `x` be a vector. Write code that prints an error if `x` is empty (has zero elements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "You can do it like this:\n",
    "```\n",
    "length(x) == 0 && println(\"x is empty\")\n",
    "```\n",
    "\n",
    "*Extra*: typically in such case one would use the `isempty` function and throw\n",
    "an exception instead of just printing information (here I assume that `x` was\n",
    "passed as an argument to the function):\n",
    "```\n",
    "isempty(x) && throw(ArgumentError(\"x is not allowed to be empty\"))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "Compute the maximum difference between two numbers in an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [2, 6, 8, 32, 16]\n",
    "b = [2.1, 1.2, 3.5, 3.2]\n",
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "You can define is as follows:\n",
    "```julia\n",
    "fun(x::AbstractVector) = maximum(x) - minimum(x)\n",
    "```\n",
    "\n",
    "or as follows:\n",
    "\n",
    "```julia\n",
    "function fun2(x::AbstractVector)\n",
    "    lo, hi = extrema(x)\n",
    "    return hi - lo\n",
    "end\n",
    "```\n",
    "Note that these two functions will work with vectors of any elements that are ordered and support subtraction (they do not have to be numbers)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "Define two functions to solve the first two exercises. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your function here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "\n",
    "Define a function that returns `true` if an input string is palindrome, `false` otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your function here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```julia\n",
    "function is_palindrome(string_var)\n",
    "    return string_var == string_var[end:-1:1]\n",
    "end\n",
    "```\n",
    "\n",
    "```bash\n",
    "a = \"Princeton\"\n",
    "b = \"HANNAH\"\n",
    "\n",
    "@show is_palindrome(a)\n",
    "@show is_palindrome(b)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6\n",
    "Define a function that counts how many times a letter is present in an input string and returns a dict of `\"letter\" => count`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your function here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```julia\n",
    "function histogram_letters(string_var)  \n",
    "    ret = Dict()\n",
    "    for k in string_var\n",
    "        ret[k] = get!(ret,k,0) + 1 # 0 è il defalt return value if the key is not present\n",
    "    end\n",
    "    return ret \n",
    "end\n",
    "```\n",
    "\n",
    "```bash\n",
    "a = \"Princeton\"\n",
    "@show (histogram_letters(a))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 7\n",
    "Define a function to calculate the volume of a sphere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your function here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```julia\n",
    "function sphere_vol(r)\n",
    "    return 4/3*pi*r^3\n",
    "end\n",
    "```\n",
    "Or, more succinctly\n",
    "```julia\n",
    "sphere_vol(r) = 4/3*pi*r^3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 8\n",
    "1. Write a function that calculates the Fibonacci numbers for positive arguments  \n",
    "\n",
    "2. Using the BenchmarkTools.jl package measure runtime of this function for n ranging from 1 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your function here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```julia\n",
    "fib(n) = n < 3 ? 1 : fib(n-1) + fib(n-2)\n",
    "```\n",
    "\n",
    "```bash\n",
    "julia> using BenchmarkTools\n",
    "\n",
    "julia> for i in 1:40\n",
    "           print(i, \" \")\n",
    "           @btime fib($i)\n",
    "       end\n",
    "```\n",
    "Notice that execution time for number `n` is roughly sum of execution times for numbers `n-1` and `n-2`.\n",
    "\n",
    "*Extra* (better version):\n",
    "```bash\n",
    "julia> const fib_dict = Dict{Int, Int}()\n",
    "function fib2(n)\n",
    "           haskey(fib_dict, n) && return fib_dict[n]\n",
    "           fib_n = n < 3 ? 1 : fib2(n-1) + fib2(n-2)\n",
    "           fib_dict[n] = fib_n\n",
    "           return fib_n\n",
    "       end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 9\n",
    "- Create a matrix of shape 2x3 containing numbers from 1 to 6 (fill the matrix columnwise with consecutive numbers).   \n",
    "\n",
    "- Next calculate sum, mean and standard deviation of each row and each column of this matrix (Hint: you can use the Statistics package)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```bash\n",
    "julia> using Statistics\n",
    "julia> mat = [1 3 5\n",
    "              2 4 6]\n",
    "\n",
    "julia> sum(mat, dims=1)\n",
    "\n",
    "julia> sum(mat, dims=2)\n",
    "\n",
    "julia> mean(mat, dims=1)\n",
    "\n",
    "julia> mean(mat, dims=2)\n",
    "\n",
    "julia> std(mat, dims=1)\n",
    "\n",
    "julia> std(mat, dims=2)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 10\n",
    "Read data stored in a gzip-compressed file `example8.csv.gz` into a `DataFrame` called `df`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```julia\n",
    "using CSV\n",
    "using DataFrames\n",
    "\n",
    "df = CSV.read(\"example8.csv.gz\", DataFrame)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 11\n",
    "Get number of rows, columns, column names and summary statistics of the `df` data frame from exercise 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```julia\n",
    "julia> nrow(df)\n",
    "4\n",
    "```\n",
    "```julia\n",
    "julia> ncol(df)\n",
    "2\n",
    "```\n",
    "```julia\n",
    "julia> names(df)\n",
    "2-element Vector{String}:\n",
    " \"number\"\n",
    " \"square\"\n",
    " ```\n",
    "```julia\n",
    "julia> describe(df)\n",
    "2×7 DataFrame\n",
    " Row │ variable  mean     min    median   max    nmissing  eltype\n",
    "     │ Symbol    Float64  Int64  Float64  Int64  Int64     DataType\n",
    "─────┼──────────────────────────────────────────────────────────────\n",
    "   1 │ number       2.5       1      2.5      4         0  Int64\n",
    "   2 │ square       7.75      2      6.5     16         0  Int64\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 12\n",
    "Add a column to `df` data frame with label \"name_string\" containing string representation of numbers in column number, i.e. [\"one\", \"two\", \"three\", \"four\"]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```bash\n",
    "julia> df.\"name string\" = [\"one\", \"two\", \"three\", \"four\"]\n",
    "4-element Vector{String}:\n",
    " \"one\"\n",
    " \"two\"\n",
    " \"three\"\n",
    " \"four\"\n",
    "```\n",
    "\n",
    "```bash\n",
    "julia> df\n",
    "4×3 DataFrame\n",
    " Row │ number  square  name string\n",
    "     │ Int64   Int64   String\n",
    "─────┼─────────────────────────────\n",
    "   1 │      1       2  one\n",
    "   2 │      2       4  two\n",
    "   3 │      3       9  three\n",
    "   4 │      4      16  four\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 13\n",
    "Check if `df` contains column `square2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "\n",
    "```bash\n",
    "hasproperty(df, :square2)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 14\n",
    "Extract column number from `df` and empty it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```bash\n",
    "julia> empty!(df[:, :number])\n",
    "Int64[]\n",
    "```\n",
    "\n",
    "Note: that you must not do `empty!(df[!, :number])` nor `empty!(df.number)` as it would corrupt the `df` data frame (these operations do non-copying extraction of a column from a data frame as opposed to `df[:, :number]` which makes a copy). For more details [DataFrames](https://github.com/JuliaData/DataFrames.jl)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 15\n",
    "\n",
    "Write a function that calculates a sum of absolute values of values stored in an array passed to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,-3, 2., 4,2.]\n",
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```\n",
    "sumabs(x) = sum(abs, x)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 16\n",
    "\n",
    "Write a function that swaps first and last element in an array in place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [2, 1, 2.3, 6.1, -1.6, -3.3]\n",
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "This can be written for example as:\n",
    "\n",
    "```julia\n",
    "function swap!(x)\n",
    "    f = x[1]\n",
    "    x[1] = x[end]\n",
    "    x[end] = f\n",
    "    return x\n",
    "end\n",
    "```\n",
    "\n",
    "Extra A more advanced way to write this function would be:\n",
    "```julia\n",
    "function swap!(x)\n",
    "    if length(x) > 1\n",
    "        x[begin], x[end] = x[end], x[begin]\n",
    "    end\n",
    "    return x\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 17"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Write a loop in global scope that calculates the sum of cubes of numbers from 1 to 10^6.   \n",
    "\n",
    "- Next use the sum function to perform the same computation.   \n",
    "\n",
    "What is the difference in timing of these operations? (Hint: use @time macro. See [link](https://docs.julialang.org/en/v1/manual/performance-tips/#Measure-performance-with-[@time](@ref)-and-pay-attention-to-memory-allocation))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "Version in global scope:\n",
    "\n",
    "```julia\n",
    "s = 0\n",
    "@time for i in 1:10^6\n",
    "  global s += i^3\n",
    "end\n",
    "```\n",
    "\n",
    "Version with a function using a sum function:\n",
    "\n",
    "```julia\n",
    "sum3(n) = sum(x -> x^3, 1:n)\n",
    "```\n",
    "\n",
    "```julia\n",
    "@time sum3(10^6)\n",
    "```\n",
    "\n",
    "Version with sum function in global scope:\n",
    "\n",
    "```julia\n",
    "@time sum(x -> x^3, 1:10^6)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 18\n",
    "Using the `@btime` macro benchmark the time of calculating the sum of one million random floats. (Include `BenchmarkTools` to use @btime macro)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "```bash\n",
    "julia> using BenchmarkTools\n",
    "julia> @btime sum($(rand(10^6))\n",
    "```\n",
    "Note that the following:\n",
    "\n",
    "```bash\n",
    "julia> @btime sum(rand(10^6))\n",
    "```\n",
    "would be an incorrect timing as you would also measure the time of generating of the vector.\n",
    "\n",
    "Alternatively you can write:\n",
    "\n",
    "```julia\n",
    "julia> x = rand(10^6);\n",
    "julia> @btime sum($x)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercize 19"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function that accepts any Integer except Bool and returns the passed value. If `Bool` is passed an error should be thrown."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "We check subtypes of Integer:\n",
    "\n",
    "```julia\n",
    "julia> subtypes(Integer)\n",
    "3-element Vector{Any}:\n",
    " Bool\n",
    " Signed\n",
    " Unsigned\n",
    "```\n",
    "\n",
    "The first way to write such a function is then:\n",
    "\n",
    "```julia\n",
    "fun1(i::Union{Signed, Unsigned}) = i\n",
    "```\n",
    "\n",
    "and now we have:\n",
    "```bash\n",
    "julia> fun1(1)\n",
    "1\n",
    "julia> fun1(true)\n",
    "ERROR: MethodError: no method matching fun1(::Bool)\n",
    "```\n",
    "\n",
    "The second way is:\n",
    "\n",
    "```julia\n",
    "fun2(i::Integer) = i\n",
    "fun2(::Bool) = throw(ArgumentError(\"Bool is not supported\"))\n",
    "```\n",
    "\n",
    "and now you have:\n",
    "\n",
    "```bash\n",
    "julia> fun2(1)\n",
    "1\n",
    "\n",
    "julia> fun2(true)\n",
    "ERROR: ArgumentError: Bool is not supported\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.9.3",
   "language": "julia",
   "name": "julia-1.9"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.9.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}