JuliaIntroduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Julia\n",
    "\n",
    "* Julia is a high-level programming language for technical computing which allows you to manipulate and analyse large data sets\n",
    "\n",
    "## Interesting features:\n",
    " * Julia is build from the ground for techical computing. \n",
    " * The language is close to the mathematical notation, for example to define a function $f(x) = 2x + 3$ in Julia is:\n",
    "\n",
    "```julia\n",
    "f(x) = 2x + 3\n",
    "```\n",
    "  \n",
    " * Julia is free and open-source software.\n",
    " * Julia's code is compiled to machine code and loops can be as fast as in other compiled languages (like Fortran or C)\n",
    "\n",
    "\n",
    "## Instructions for installing Julia on your laptop\n",
    "\n",
    "* If you want to install Julia on your laptop later on, here are some instructions\n",
    "* Go to http://julialang.org/downloads/\n",
    "* There are various editor with support for Julia (like atom, notepad++, emacs, vim...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ways to run Julia:\n",
    "\n",
    "#### Command line\n",
    "\n",
    "* Use the `Tab` key to complete file, variable and function names\n",
    "* `Up` and `down arrows` key to repeat a previously entered command\n",
    "* `Control-R` to search a command\n",
    "* On Windows enable \"[quick edit](https://www.tekrevue.com/tip/boost-productivity-quickedit-mode-windows-command-prompt/)\" for easier copy and pasting\n",
    "![cmd](Fig/julia-commandline.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Jupyter notebook (web-browser)\n",
    "\n",
    "* Web-interface for Julia (among others)\n",
    "* The Julia package `IJulia` which also installs Jupyter http://jupyter.org/\n",
    "* Various [keyboard short cuts](https://www.cheatography.com/weidadeyue/cheat-sheets/jupyter-notebook/) are defined to be productive with jupyter notebooks\n",
    "* General documentation of [Jupyter Notebooks](http://jupyter-notebook.readthedocs.io)\n",
    "\n",
    "![cmd](Fig/julia-jupyter.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Text can be formatted using markdown."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Markdown\n",
    "\n",
    "This is an explanation\n",
    "* item one\n",
    "* item two\n",
    "   * sub item one\n",
    "   * sub item two\n",
    "$$ c^2 = a^2 + b^2 $$ \n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### VS Code\n",
    "\n",
    "* Integrates an editor, command line and documentation browser\n",
    "* Installation instructions are available at https://www.julia-vscode.org/, https://www.julia-vscode.org/docs/stable/\n",
    "\n",
    "![atom](Fig/julia-vs-code.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Julia documentation\n",
    "\n",
    "* The manual: https://docs.julialang.org\n",
    "* Tutorials and books: https://julialang.org/learning/\n",
    "\n",
    "\n",
    "## Comparision with other languages\n",
    "\n",
    "\n",
    "* [Noteworthy Differences from other Languages](https://docs.julialang.org/en/v1.0/manual/noteworthy-differences/)\n",
    "* In particular (difference from Matlab):\n",
    "   * Julia arrays are indexed with square brackets, `A[i,j]`.\n",
    "   * Julia arrays are assigned by reference. After A=B, changing elements of B will modify A as well.\n",
    "   * Julia function parameters are passed and assigned by reference. If a function modifies an array, the changes will be visible in the caller.\n",
    "   * A bang (!) indicates if a function changes one of its argument\n",
    "   * In Julia, parentheses must be used to call a function with zero arguments, like in tic() and toc().\n",
    "   * Julia's single quotes enclose characters, not strings.\n",
    "   * Julia does not automatically grow arrays in an assignment statement. \n",
    "\n",
    "* Difference from Python:\n",
    "   * Julia requires end to end a block.\n",
    "   * In Julia, indexing of arrays, strings, etc. is **1-based** not 0-based.\n",
    "   * Julia's slice indexing includes the last element, unlike in Python. `a[2:3]` in Julia is `a[1:3]` in Python.\n",
    "   * Julia does not support negative indexes. In particular, the last element of a list or array is indexed with end in Julia, not -1 as in Python.\n",
    "\n",
    "\n",
    "\n",
    "* [MATLAB–Python–Julia cheatsheet](https://cheatsheets.quantecon.org/)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# First steps in Julia\n",
    "\n",
    "## Numbers\n",
    "\n",
    "* Use a dot (.) as decimal separator (e.g. 3.14 and not 3,14)\n",
    "* You can use the scientific notation $a \\times 10^{-b}$ using the e-notation. (e.g. $3 \\times10^{-7}$ becomes 3e-7) \n",
    "* Use Julia as a calculator:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Control-Enter to execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0e-30"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1e-30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "π = 3.1415926535897..."
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2246467991473532e-16"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.4492935982947064e-16"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(2*pi)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The usual operator precedence applies\n",
    "\n",
    "\n",
    "## Useful constants\n",
    "\n",
    "Various constants are also pre-defined: π (pi), e (Euler's number), im (the imaginary number), Inf (Infinity, result from e.g. 1/0) and NaN (Not a Number - result from e.g. 0/0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NaN"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0. / 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "* Numbers (and any other data type) can be put into variables\n",
    "* The value of a variable is referenced by its name\n",
    "* A variable name can be composed by letters (a-z and A-Z, including greek letters, accents,...), numbers (0-9), underscore (_) and some unicode symbols (like greek letters). The first character cannot be a number.\n",
    "\n",
    "* Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp = 21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(temp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see the content of the variable `temp`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temp = 21\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@show temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any expression can now include the variable `temp`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp2 = 2*temp\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The variable `temp` has now the value 21. The value of the variable can be changed later on.\n",
    "* An assignment without a final semicolon echos its value to the screen\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "* Delimited by double quotes\n",
    "    \t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this\n",
      "that"
     ]
    }
   ],
   "source": [
    "print(\"this\\nthat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world. Say \"hi\" ! "
     ]
    }
   ],
   "source": [
    "s = \"Hello world. Say \\\"hi\\\" ! \"\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is Alexander"
     ]
    }
   ],
   "source": [
    "name = \"Alexander\"\n",
    "message = \"Hello, my name is \" * name\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "message = \"Hello, my name is Alexander\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"Hello, my name is Alexander\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@show message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is Alexander"
     ]
    }
   ],
   "source": [
    "name = \"Alexander\"\n",
    "message = \"Hello, my name is $name\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperature today is 21"
     ]
    }
   ],
   "source": [
    "print(\"Temperature today is $(temp)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Symbols\n",
    "\n",
    "* A symbol is an [interned string](https://en.wikipedia.org/wiki/String_interning) identifier which means that every  string symbol is replaced internally by a number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* This makes comparision between symbols faster than comparision between strings\n",
    "* Symbols are also used in metaprogramming (julia code which produces julia code)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":mysymbol"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ":mysymbol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectors and matrices\n",
    "\n",
    "* Vectors are list of numbers. The column vector $\\left(\\begin{array}{c}1 \\\\ 2 \\\\ 3 \\end{array} \\right)$ is represented by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 1\n",
       " 2\n",
       " 3"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Matrices are tables of numbers. Rows are separated by a semicolon. The matrix \n",
    "$\\left(\\begin{array}{cc}1 & 2 \\\\ 3 & 4 \\end{array} \\right)$ is represented by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Matrix{Int64}:\n",
       " 1  2\n",
       " 3  4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1 2;  3 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The determinant  can be for example computed with `det`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.0"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using LinearAlgebra\n",
    "det([1 2; 3 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* There are no \"row vectors\", just matrices with one row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×3 Matrix{Int64}:\n",
       " 1  2  3"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1 2 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 1\n",
       " 2\n",
       " 3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ranges\n",
    "\n",
    "* Consecutive elements can be written as\n",
    "\n",
    "    first:step:last\n",
    "    \n",
    "* or simply, if the step is 1,\n",
    "    \t\n",
    "    first:last\n",
    "    \n",
    "* Use the function `collect` or `[first:step:last;]` to transform a range into a vector:\n",
    "   \n",
    "Instead of typing this:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One could simply write this as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1:5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1:5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the full list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(1:5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now if we need only every second element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1:2:5"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1:2:6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 1\n",
       " 3\n",
       " 5"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(1:2:6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9-element Vector{Int64}:\n",
       "  1\n",
       "  3\n",
       "  4\n",
       "  5\n",
       "  6\n",
       "  7\n",
       "  8\n",
       "  9\n",
       " 10"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter(i -> i !== 2,1:10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that 6 is not part of the previous range."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing\n",
    "\n",
    "* Consider the following vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 7\n",
       " 3"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [2,5,7,19,2,2,3]\n",
    "a[[3,end]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Individual elements of a vector or matrix can be addressed by their index\n",
    "* The second element of a vector `a` is for example `a[2]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[length(a)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The special word `end` refers to the last index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* One can also use a list of indexes to extract a part of the vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       "  5\n",
       "  7\n",
       " 19"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[a[2], a[3], a[4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       "  5\n",
       "  7\n",
       " 19"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[[2,3,4]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Or simply:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       "  5\n",
       "  7\n",
       " 19"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The symbol colon : is a short-hand for 1:end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       "  2\n",
       "  5\n",
       "  7\n",
       " 19\n",
       "  2"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1:end]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       "  2\n",
       "  5\n",
       "  7\n",
       " 19\n",
       "  2"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix indexing\n",
    "\n",
    "* For matrices, two indices are used.\n",
    "* The element at the second row and the first column of a matrix A is for example A[2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Matrix{Int64}:\n",
       " 1  2\n",
       " 3  4"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [1 2; 3 4]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×5 Matrix{Int64}:\n",
       " 1  2  3  4  5\n",
       " 1  2  3  4  5"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1 2 3 4 5]\n",
    "b = 1:5\n",
    "[a; b']\n",
    "#[a; (1:5)']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 2\n",
       " 4"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 1\n",
       " 2"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = [6 7 8; 5 2 4; 6 7 8; 5 2 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4×3 Matrix{Int64}:\n",
       " 6  7  8\n",
       " 5  2  4\n",
       " 6  7  8\n",
       " 5  2  4"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1 2 3;\n",
    "     5 2 4; \n",
    "     6 7 8;\n",
    "     5 2 4; \n",
    "     6 7 8;\n",
    "     5 2 4; \n",
    "     6 7 8;\n",
    "     5 6 6]\n",
    "b = a[3:end-2,:]\n",
    "@show b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  \n",
    "    \n",
    "* If a matrix is indexed with only one subscript, the matrix is treaded as a vector where all columns are concatenated\n",
    "\n",
    "* Julia supports also higher-dimensional arrays and indexing works similarily.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operators\n",
    "\n",
    "* Scalar and matrix operations: + sum, - difference, * multiplication, / division\n",
    "* Element-wise matrix operations: .* multiply element-wise, ./ divide element-wise \n",
    "\n",
    "## Comparison operators\n",
    "\n",
    " * equal (==) and different (!=)\n",
    " \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 2\n",
       " 3\n",
       " 4"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] .+ 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9 == 3*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1 2 3] == [1 3 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 10.0\n",
       " 10.0\n",
       " 10.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[10,20,30] ./ [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×3 BitMatrix:\n",
       " 1  0  0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1 2 3] .== [1 3 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Be aware of the limited precision of floating point numbers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.0000000000000001 == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * element-wise equal (.==), element-wise different (.!=)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×3 BitMatrix:\n",
       " 1  0  0"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1 2 3] .== [1 3 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* comparision between numbers: <, >, <= (≤), => (≥)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "30 > 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* element-wise comparision between vector and matrices: .<, .>, .<= (.≤), .=> (.≥)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element BitVector:\n",
       " 0\n",
       " 0\n",
       " 1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] .> 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element BitVector:\n",
       " 0\n",
       " 1\n",
       " 1"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] .> [3,1,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* logical \"and\" (&&) logical \"or\" (||) (with short-circuit evaluation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperature = 30;\n",
    "precipitation = 10;\n",
    "\n",
    "if temperature > 25 && precipitation == 0\n",
    "    print(\"go outside!\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* logical element-wise \"and\" (.&) logical element-wise \"or\" (.|)\n",
    "\n",
    "* The results of such operators can also be used to index an array\n",
    "    \n",
    "* For example return all elements in the variable T which are greater than 10 but less than 20.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 1\n",
       " 4"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T = [27,17,20,26,32]\n",
    "findall(20 .< T .< 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 21\n",
       " 21"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[20 .< T .< 30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 21\n",
       " 21"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[20 .< T .& T .< 30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9-element BitVector:\n",
       " 1\n",
       " 1\n",
       " 1\n",
       " 1\n",
       " 1\n",
       " 1\n",
       " 1\n",
       " 1\n",
       " 1"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T .< 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 27\n",
       " 26"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T = [27,17,20,26,32]\n",
    "T[20 .< T .& T .< 30]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The function `findall(condition)` returns the indexes of all elements where the condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 27\n",
       " 17\n",
       " 20\n",
       " 26\n",
       " 32"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int64}:\n",
       " 1\n",
       " 4"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "findall(20 .< T .& T .< 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* false is zero and true is 1. For instance to count the number of elements in the vector T which are larger than 20 one can use sum(T .> 20)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([1,0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 27\n",
       " 17\n",
       " 20\n",
       " 26\n",
       " 32"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element BitVector:\n",
       " 1\n",
       " 0\n",
       " 0\n",
       " 1\n",
       " 1"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T .> 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(T .> 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Useful functions\n",
    "\n",
    "* sin, cos, tan: trigonometric functions\n",
    "* asin, acos, atan: inverse trigonometric functions\n",
    "* log, log2, log10: natural, base 2 and base 10 logarithms: \n",
    "* exp: exponentiation\n",
    "* abs: absolute value\n",
    "* sqrt: square root\n",
    "* mean: mean\n",
    "* median: median\n",
    "* std: standard deviation\n",
    "* var: variance\n",
    "* mod: modulo (useful to manipulate e.g. the longitude)\n",
    "* isnan: Check if variable is NaN. Note that NaN == NaN is false!\n",
    "* inv: inverse of a matrix\n",
    "* sum: sum of all elements\n",
    "* prod: product of all elements\n",
    "* maximum,minimum: maximum,minimum value in an array\n",
    "* max,min: maximum,minimum value of all arguments\n",
    "* isnan: true if a value is NaN\n",
    "* isinf: true if a value is Inf\n",
    "\n",
    "These function can also operate of a given dimension: sum(array,dimension)\n",
    "\n",
    "Find out more of these function by typing ? followed by the function name. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mm\u001b[22m \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mm\u001b[22m! \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mm\u001b[22mmary cum\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mm\u001b[22m cum\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mm\u001b[22m! i\u001b[0m\u001b[1ms\u001b[22mn\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mm\u001b[22meric Method\u001b[0m\u001b[1mS\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mm\u001b[22mmary Ver\u001b[0m\u001b[1ms\u001b[22mionN\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mm\u001b[22mber\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "sum(f, itr; [init])\n",
       "\\end{verbatim}\n",
       "Sum the results of calling function \\texttt{f} on each element of \\texttt{itr}.\n",
       "\n",
       "The return type is \\texttt{Int} for signed integers of less than system word size, and \\texttt{UInt} for unsigned integers of less than system word size.  For all other arguments, a common return type is found to which all arguments are promoted.\n",
       "\n",
       "The value returned for empty \\texttt{itr} can be specified by \\texttt{init}. It must be the additive identity (i.e. zero) as it is unspecified whether \\texttt{init} is used for non-empty collections.\n",
       "\n",
       "\\begin{quote}\n",
       "\\textbf{compat}\n",
       "\n",
       "Julia 1.6\n",
       "\n",
       "Keyword argument \\texttt{init} requires Julia 1.6 or later.\n",
       "\n",
       "\\end{quote}\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> sum(abs2, [2; 3; 4])\n",
       "29\n",
       "\\end{verbatim}\n",
       "Note the important difference between \\texttt{sum(A)} and \\texttt{reduce(+, A)} for arrays with small integer eltype:\n",
       "\n",
       "\\begin{verbatim}\n",
       "julia> sum(Int8[100, 28])\n",
       "128\n",
       "\n",
       "julia> reduce(+, Int8[100, 28])\n",
       "-128\n",
       "\\end{verbatim}\n",
       "In the former case, the integers are widened to system word size and therefore the result is 128. In the latter case, no such widening happens and integer overflow results in -128.\n",
       "\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "sum(itr; [init])\n",
       "\\end{verbatim}\n",
       "Returns the sum of all elements in a collection.\n",
       "\n",
       "The return type is \\texttt{Int} for signed integers of less than system word size, and \\texttt{UInt} for unsigned integers of less than system word size.  For all other arguments, a common return type is found to which all arguments are promoted.\n",
       "\n",
       "The value returned for empty \\texttt{itr} can be specified by \\texttt{init}. It must be the additive identity (i.e. zero) as it is unspecified whether \\texttt{init} is used for non-empty collections.\n",
       "\n",
       "\\begin{quote}\n",
       "\\textbf{compat}\n",
       "\n",
       "Julia 1.6\n",
       "\n",
       "Keyword argument \\texttt{init} requires Julia 1.6 or later.\n",
       "\n",
       "\\end{quote}\n",
       "See also: \\href{@ref}{\\texttt{reduce}}, \\href{@ref}{\\texttt{mapreduce}}, \\href{@ref}{\\texttt{count}}, \\href{@ref}{\\texttt{union}}.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> sum(1:20)\n",
       "210\n",
       "\n",
       "julia> sum(1:20; init = 0.0)\n",
       "210.0\n",
       "\\end{verbatim}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "sum(A::AbstractArray; dims)\n",
       "\\end{verbatim}\n",
       "Sum elements of an array over the given dimensions.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> A = [1 2; 3 4]\n",
       "2×2 Matrix{Int64}:\n",
       " 1  2\n",
       " 3  4\n",
       "\n",
       "julia> sum(A, dims=1)\n",
       "1×2 Matrix{Int64}:\n",
       " 4  6\n",
       "\n",
       "julia> sum(A, dims=2)\n",
       "2×1 Matrix{Int64}:\n",
       " 3\n",
       " 7\n",
       "\\end{verbatim}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "sum(f, A::AbstractArray; dims)\n",
       "\\end{verbatim}\n",
       "Sum the results of calling function \\texttt{f} on each element of an array over the given dimensions.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> A = [1 2; 3 4]\n",
       "2×2 Matrix{Int64}:\n",
       " 1  2\n",
       " 3  4\n",
       "\n",
       "julia> sum(abs2, A, dims=1)\n",
       "1×2 Matrix{Int64}:\n",
       " 10  20\n",
       "\n",
       "julia> sum(abs2, A, dims=2)\n",
       "2×1 Matrix{Int64}:\n",
       "  5\n",
       " 25\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "```\n",
       "sum(f, itr; [init])\n",
       "```\n",
       "\n",
       "Sum the results of calling function `f` on each element of `itr`.\n",
       "\n",
       "The return type is `Int` for signed integers of less than system word size, and `UInt` for unsigned integers of less than system word size.  For all other arguments, a common return type is found to which all arguments are promoted.\n",
       "\n",
       "The value returned for empty `itr` can be specified by `init`. It must be the additive identity (i.e. zero) as it is unspecified whether `init` is used for non-empty collections.\n",
       "\n",
       "!!! compat \"Julia 1.6\"\n",
       "    Keyword argument `init` requires Julia 1.6 or later.\n",
       "\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> sum(abs2, [2; 3; 4])\n",
       "29\n",
       "```\n",
       "\n",
       "Note the important difference between `sum(A)` and `reduce(+, A)` for arrays with small integer eltype:\n",
       "\n",
       "```jldoctest\n",
       "julia> sum(Int8[100, 28])\n",
       "128\n",
       "\n",
       "julia> reduce(+, Int8[100, 28])\n",
       "-128\n",
       "```\n",
       "\n",
       "In the former case, the integers are widened to system word size and therefore the result is 128. In the latter case, no such widening happens and integer overflow results in -128.\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "sum(itr; [init])\n",
       "```\n",
       "\n",
       "Returns the sum of all elements in a collection.\n",
       "\n",
       "The return type is `Int` for signed integers of less than system word size, and `UInt` for unsigned integers of less than system word size.  For all other arguments, a common return type is found to which all arguments are promoted.\n",
       "\n",
       "The value returned for empty `itr` can be specified by `init`. It must be the additive identity (i.e. zero) as it is unspecified whether `init` is used for non-empty collections.\n",
       "\n",
       "!!! compat \"Julia 1.6\"\n",
       "    Keyword argument `init` requires Julia 1.6 or later.\n",
       "\n",
       "\n",
       "See also: [`reduce`](@ref), [`mapreduce`](@ref), [`count`](@ref), [`union`](@ref).\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> sum(1:20)\n",
       "210\n",
       "\n",
       "julia> sum(1:20; init = 0.0)\n",
       "210.0\n",
       "```\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "sum(A::AbstractArray; dims)\n",
       "```\n",
       "\n",
       "Sum elements of an array over the given dimensions.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> A = [1 2; 3 4]\n",
       "2×2 Matrix{Int64}:\n",
       " 1  2\n",
       " 3  4\n",
       "\n",
       "julia> sum(A, dims=1)\n",
       "1×2 Matrix{Int64}:\n",
       " 4  6\n",
       "\n",
       "julia> sum(A, dims=2)\n",
       "2×1 Matrix{Int64}:\n",
       " 3\n",
       " 7\n",
       "```\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "sum(f, A::AbstractArray; dims)\n",
       "```\n",
       "\n",
       "Sum the results of calling function `f` on each element of an array over the given dimensions.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> A = [1 2; 3 4]\n",
       "2×2 Matrix{Int64}:\n",
       " 1  2\n",
       " 3  4\n",
       "\n",
       "julia> sum(abs2, A, dims=1)\n",
       "1×2 Matrix{Int64}:\n",
       " 10  20\n",
       "\n",
       "julia> sum(abs2, A, dims=2)\n",
       "2×1 Matrix{Int64}:\n",
       "  5\n",
       " 25\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  sum(f, itr; [init])\u001b[39m\n",
       "\n",
       "  Sum the results of calling function \u001b[36mf\u001b[39m on each element of \u001b[36mitr\u001b[39m.\n",
       "\n",
       "  The return type is \u001b[36mInt\u001b[39m for signed integers of less than system word size,\n",
       "  and \u001b[36mUInt\u001b[39m for unsigned integers of less than system word size. For all other\n",
       "  arguments, a common return type is found to which all arguments are\n",
       "  promoted.\n",
       "\n",
       "  The value returned for empty \u001b[36mitr\u001b[39m can be specified by \u001b[36minit\u001b[39m. It must be the\n",
       "  additive identity (i.e. zero) as it is unspecified whether \u001b[36minit\u001b[39m is used for\n",
       "  non-empty collections.\n",
       "\n",
       "\u001b[39m\u001b[1m  │ \u001b[22m\u001b[39m\u001b[1mJulia 1.6\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m  Keyword argument \u001b[36minit\u001b[39m requires Julia 1.6 or later.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> sum(abs2, [2; 3; 4])\u001b[39m\n",
       "\u001b[36m  29\u001b[39m\n",
       "\n",
       "  Note the important difference between \u001b[36msum(A)\u001b[39m and \u001b[36mreduce(+, A)\u001b[39m for arrays\n",
       "  with small integer eltype:\n",
       "\n",
       "\u001b[36m  julia> sum(Int8[100, 28])\u001b[39m\n",
       "\u001b[36m  128\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> reduce(+, Int8[100, 28])\u001b[39m\n",
       "\u001b[36m  -128\u001b[39m\n",
       "\n",
       "  In the former case, the integers are widened to system word size and\n",
       "  therefore the result is 128. In the latter case, no such widening happens\n",
       "  and integer overflow results in -128.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  sum(itr; [init])\u001b[39m\n",
       "\n",
       "  Returns the sum of all elements in a collection.\n",
       "\n",
       "  The return type is \u001b[36mInt\u001b[39m for signed integers of less than system word size,\n",
       "  and \u001b[36mUInt\u001b[39m for unsigned integers of less than system word size. For all other\n",
       "  arguments, a common return type is found to which all arguments are\n",
       "  promoted.\n",
       "\n",
       "  The value returned for empty \u001b[36mitr\u001b[39m can be specified by \u001b[36minit\u001b[39m. It must be the\n",
       "  additive identity (i.e. zero) as it is unspecified whether \u001b[36minit\u001b[39m is used for\n",
       "  non-empty collections.\n",
       "\n",
       "\u001b[39m\u001b[1m  │ \u001b[22m\u001b[39m\u001b[1mJulia 1.6\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m  Keyword argument \u001b[36minit\u001b[39m requires Julia 1.6 or later.\n",
       "\n",
       "  See also: \u001b[36mreduce\u001b[39m, \u001b[36mmapreduce\u001b[39m, \u001b[36mcount\u001b[39m, \u001b[36munion\u001b[39m.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> sum(1:20)\u001b[39m\n",
       "\u001b[36m  210\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> sum(1:20; init = 0.0)\u001b[39m\n",
       "\u001b[36m  210.0\u001b[39m\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  sum(A::AbstractArray; dims)\u001b[39m\n",
       "\n",
       "  Sum elements of an array over the given dimensions.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> A = [1 2; 3 4]\u001b[39m\n",
       "\u001b[36m  2×2 Matrix{Int64}:\u001b[39m\n",
       "\u001b[36m   1  2\u001b[39m\n",
       "\u001b[36m   3  4\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> sum(A, dims=1)\u001b[39m\n",
       "\u001b[36m  1×2 Matrix{Int64}:\u001b[39m\n",
       "\u001b[36m   4  6\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> sum(A, dims=2)\u001b[39m\n",
       "\u001b[36m  2×1 Matrix{Int64}:\u001b[39m\n",
       "\u001b[36m   3\u001b[39m\n",
       "\u001b[36m   7\u001b[39m\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  sum(f, A::AbstractArray; dims)\u001b[39m\n",
       "\n",
       "  Sum the results of calling function \u001b[36mf\u001b[39m on each element of an array over the\n",
       "  given dimensions.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> A = [1 2; 3 4]\u001b[39m\n",
       "\u001b[36m  2×2 Matrix{Int64}:\u001b[39m\n",
       "\u001b[36m   1  2\u001b[39m\n",
       "\u001b[36m   3  4\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> sum(abs2, A, dims=1)\u001b[39m\n",
       "\u001b[36m  1×2 Matrix{Int64}:\u001b[39m\n",
       "\u001b[36m   10  20\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> sum(abs2, A, dims=2)\u001b[39m\n",
       "\u001b[36m  2×1 Matrix{Int64}:\u001b[39m\n",
       "\u001b[36m    5\u001b[39m\n",
       "\u001b[36m   25\u001b[39m"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1me\u001b[22m\u001b[0m\u001b[1mn\u001b[22m is\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1me\u001b[22m\u001b[0m\u001b[1mn\u001b[22m pr\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1me\u001b[22mrty\u001b[0m\u001b[1mn\u001b[22mames C\u001b[0m\u001b[1mo\u001b[22mm\u001b[0m\u001b[1mp\u001b[22mos\u001b[0m\u001b[1me\u001b[22mdFu\u001b[0m\u001b[1mn\u001b[22mction C\u001b[0m\u001b[1mo\u001b[22mm\u001b[0m\u001b[1mp\u001b[22mosit\u001b[0m\u001b[1me\u001b[22mExceptio\u001b[0m\u001b[1mn\u001b[22m \u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1me\u001b[22mrm\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "open(f::Function, args...; kwargs...)\n",
       "\\end{verbatim}\n",
       "Apply the function \\texttt{f} to the result of \\texttt{open(args...; kwargs...)} and close the resulting file descriptor upon completion.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> open(\"myfile.txt\", \"w\") do io\n",
       "           write(io, \"Hello world!\")\n",
       "       end;\n",
       "\n",
       "julia> open(f->read(f, String), \"myfile.txt\")\n",
       "\"Hello world!\"\n",
       "\n",
       "julia> rm(\"myfile.txt\")\n",
       "\\end{verbatim}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "open(filename::AbstractString; lock = true, keywords...) -> IOStream\n",
       "\\end{verbatim}\n",
       "Open a file in a mode specified by five boolean keyword arguments:\n",
       "\n",
       "\\begin{tabular}\n",
       "{l | l | l}\n",
       "Keyword & Description & Default \\\\\n",
       "\\hline\n",
       "\\texttt{read} & open for reading & \\texttt{!write} \\\\\n",
       "\\texttt{write} & open for writing & \\texttt{truncate | append} \\\\\n",
       "\\texttt{create} & create if non-existent & \\texttt{!read \\& write | truncate | append} \\\\\n",
       "\\texttt{truncate} & truncate to zero size & \\texttt{!read \\& write} \\\\\n",
       "\\texttt{append} & seek to end & \\texttt{false} \\\\\n",
       "\\end{tabular}\n",
       "The default when no keywords are passed is to open files for reading only. Returns a stream for accessing the opened file.\n",
       "\n",
       "The \\texttt{lock} keyword argument controls whether operations will be locked for safe multi-threaded access.\n",
       "\n",
       "\\begin{quote}\n",
       "\\textbf{compat}\n",
       "\n",
       "Julia 1.5\n",
       "\n",
       "The \\texttt{lock} argument is available as of Julia 1.5.\n",
       "\n",
       "\\end{quote}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "open(filename::AbstractString, [mode::AbstractString]; lock = true) -> IOStream\n",
       "\\end{verbatim}\n",
       "Alternate syntax for open, where a string-based mode specifier is used instead of the five booleans. The values of \\texttt{mode} correspond to those from \\texttt{fopen(3)} or Perl \\texttt{open}, and are equivalent to setting the following boolean groups:\n",
       "\n",
       "\\begin{tabular}\n",
       "{l | l | l}\n",
       "Mode & Description & Keywords \\\\\n",
       "\\hline\n",
       "\\texttt{r} & read & none \\\\\n",
       "\\texttt{w} & write, create, truncate & \\texttt{write = true} \\\\\n",
       "\\texttt{a} & write, create, append & \\texttt{append = true} \\\\\n",
       "\\texttt{r+} & read, write & \\texttt{read = true, write = true} \\\\\n",
       "\\texttt{w+} & read, write, create, truncate & \\texttt{truncate = true, read = true} \\\\\n",
       "\\texttt{a+} & read, write, create, append & \\texttt{append = true, read = true} \\\\\n",
       "\\end{tabular}\n",
       "The \\texttt{lock} keyword argument controls whether operations will be locked for safe multi-threaded access.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> io = open(\"myfile.txt\", \"w\");\n",
       "\n",
       "julia> write(io, \"Hello world!\");\n",
       "\n",
       "julia> close(io);\n",
       "\n",
       "julia> io = open(\"myfile.txt\", \"r\");\n",
       "\n",
       "julia> read(io, String)\n",
       "\"Hello world!\"\n",
       "\n",
       "julia> write(io, \"This file is read only\")\n",
       "ERROR: ArgumentError: write failed, IOStream is not writeable\n",
       "[...]\n",
       "\n",
       "julia> close(io)\n",
       "\n",
       "julia> io = open(\"myfile.txt\", \"a\");\n",
       "\n",
       "julia> write(io, \"This stream is not read only\")\n",
       "28\n",
       "\n",
       "julia> close(io)\n",
       "\n",
       "julia> rm(\"myfile.txt\")\n",
       "\\end{verbatim}\n",
       "\\begin{quote}\n",
       "\\textbf{compat}\n",
       "\n",
       "Julia 1.5\n",
       "\n",
       "The \\texttt{lock} argument is available as of Julia 1.5.\n",
       "\n",
       "\\end{quote}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "open(fd::OS_HANDLE) -> IO\n",
       "\\end{verbatim}\n",
       "Take a raw file descriptor wrap it in a Julia-aware IO type, and take ownership of the fd handle. Call \\texttt{open(Libc.dup(fd))} to avoid the ownership capture of the original handle.\n",
       "\n",
       "\\begin{quote}\n",
       "\\textbf{warning}\n",
       "\n",
       "Warning\n",
       "\n",
       "Do not call this on a handle that's already owned by some other part of the system.\n",
       "\n",
       "\\end{quote}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "open(command, mode::AbstractString, stdio=devnull)\n",
       "\\end{verbatim}\n",
       "Run \\texttt{command} asynchronously. Like \\texttt{open(command, stdio; read, write)} except specifying the read and write flags via a mode string instead of keyword arguments. Possible mode strings are:\n",
       "\n",
       "\\begin{tabular}\n",
       "{l | l | l}\n",
       "Mode & Description & Keywords \\\\\n",
       "\\hline\n",
       "\\texttt{r} & read & none \\\\\n",
       "\\texttt{w} & write & \\texttt{write = true} \\\\\n",
       "\\texttt{r+} & read, write & \\texttt{read = true, write = true} \\\\\n",
       "\\texttt{w+} & read, write & \\texttt{read = true, write = true} \\\\\n",
       "\\end{tabular}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "open(command, stdio=devnull; write::Bool = false, read::Bool = !write)\n",
       "\\end{verbatim}\n",
       "Start running \\texttt{command} asynchronously, and return a \\texttt{process::IO} object.  If \\texttt{read} is true, then reads from the process come from the process's standard output and \\texttt{stdio} optionally specifies the process's standard input stream.  If \\texttt{write} is true, then writes go to the process's standard input and \\texttt{stdio} optionally specifies the process's standard output stream. The process's standard error stream is connected to the current global \\texttt{stderr}.\n",
       "\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "open(f::Function, command, args...; kwargs...)\n",
       "\\end{verbatim}\n",
       "Similar to \\texttt{open(command, args...; kwargs...)}, but calls \\texttt{f(stream)} on the resulting process stream, then closes the input stream and waits for the process to complete. Return the value returned by \\texttt{f} on success. Throw an error if the process failed, or if the process attempts to print anything to stdout.\n",
       "\n"
      ],
      "text/markdown": [
       "```\n",
       "open(f::Function, args...; kwargs...)\n",
       "```\n",
       "\n",
       "Apply the function `f` to the result of `open(args...; kwargs...)` and close the resulting file descriptor upon completion.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> open(\"myfile.txt\", \"w\") do io\n",
       "           write(io, \"Hello world!\")\n",
       "       end;\n",
       "\n",
       "julia> open(f->read(f, String), \"myfile.txt\")\n",
       "\"Hello world!\"\n",
       "\n",
       "julia> rm(\"myfile.txt\")\n",
       "```\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "open(filename::AbstractString; lock = true, keywords...) -> IOStream\n",
       "```\n",
       "\n",
       "Open a file in a mode specified by five boolean keyword arguments:\n",
       "\n",
       "| Keyword    | Description            | Default                               |\n",
       "|:---------- |:---------------------- |:------------------------------------- |\n",
       "| `read`     | open for reading       | `!write`                              |\n",
       "| `write`    | open for writing       | `truncate \\| append`                  |\n",
       "| `create`   | create if non-existent | `!read & write \\| truncate \\| append` |\n",
       "| `truncate` | truncate to zero size  | `!read & write`                       |\n",
       "| `append`   | seek to end            | `false`                               |\n",
       "\n",
       "The default when no keywords are passed is to open files for reading only. Returns a stream for accessing the opened file.\n",
       "\n",
       "The `lock` keyword argument controls whether operations will be locked for safe multi-threaded access.\n",
       "\n",
       "!!! compat \"Julia 1.5\"\n",
       "    The `lock` argument is available as of Julia 1.5.\n",
       "\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "open(filename::AbstractString, [mode::AbstractString]; lock = true) -> IOStream\n",
       "```\n",
       "\n",
       "Alternate syntax for open, where a string-based mode specifier is used instead of the five booleans. The values of `mode` correspond to those from `fopen(3)` or Perl `open`, and are equivalent to setting the following boolean groups:\n",
       "\n",
       "| Mode | Description                   | Keywords                       |\n",
       "|:---- |:----------------------------- |:------------------------------ |\n",
       "| `r`  | read                          | none                           |\n",
       "| `w`  | write, create, truncate       | `write = true`                 |\n",
       "| `a`  | write, create, append         | `append = true`                |\n",
       "| `r+` | read, write                   | `read = true, write = true`    |\n",
       "| `w+` | read, write, create, truncate | `truncate = true, read = true` |\n",
       "| `a+` | read, write, create, append   | `append = true, read = true`   |\n",
       "\n",
       "The `lock` keyword argument controls whether operations will be locked for safe multi-threaded access.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> io = open(\"myfile.txt\", \"w\");\n",
       "\n",
       "julia> write(io, \"Hello world!\");\n",
       "\n",
       "julia> close(io);\n",
       "\n",
       "julia> io = open(\"myfile.txt\", \"r\");\n",
       "\n",
       "julia> read(io, String)\n",
       "\"Hello world!\"\n",
       "\n",
       "julia> write(io, \"This file is read only\")\n",
       "ERROR: ArgumentError: write failed, IOStream is not writeable\n",
       "[...]\n",
       "\n",
       "julia> close(io)\n",
       "\n",
       "julia> io = open(\"myfile.txt\", \"a\");\n",
       "\n",
       "julia> write(io, \"This stream is not read only\")\n",
       "28\n",
       "\n",
       "julia> close(io)\n",
       "\n",
       "julia> rm(\"myfile.txt\")\n",
       "```\n",
       "\n",
       "!!! compat \"Julia 1.5\"\n",
       "    The `lock` argument is available as of Julia 1.5.\n",
       "\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "open(fd::OS_HANDLE) -> IO\n",
       "```\n",
       "\n",
       "Take a raw file descriptor wrap it in a Julia-aware IO type, and take ownership of the fd handle. Call `open(Libc.dup(fd))` to avoid the ownership capture of the original handle.\n",
       "\n",
       "!!! warning\n",
       "    Do not call this on a handle that's already owned by some other part of the system.\n",
       "\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "open(command, mode::AbstractString, stdio=devnull)\n",
       "```\n",
       "\n",
       "Run `command` asynchronously. Like `open(command, stdio; read, write)` except specifying the read and write flags via a mode string instead of keyword arguments. Possible mode strings are:\n",
       "\n",
       "| Mode | Description | Keywords                    |\n",
       "|:---- |:----------- |:--------------------------- |\n",
       "| `r`  | read        | none                        |\n",
       "| `w`  | write       | `write = true`              |\n",
       "| `r+` | read, write | `read = true, write = true` |\n",
       "| `w+` | read, write | `read = true, write = true` |\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "open(command, stdio=devnull; write::Bool = false, read::Bool = !write)\n",
       "```\n",
       "\n",
       "Start running `command` asynchronously, and return a `process::IO` object.  If `read` is true, then reads from the process come from the process's standard output and `stdio` optionally specifies the process's standard input stream.  If `write` is true, then writes go to the process's standard input and `stdio` optionally specifies the process's standard output stream. The process's standard error stream is connected to the current global `stderr`.\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "open(f::Function, command, args...; kwargs...)\n",
       "```\n",
       "\n",
       "Similar to `open(command, args...; kwargs...)`, but calls `f(stream)` on the resulting process stream, then closes the input stream and waits for the process to complete. Return the value returned by `f` on success. Throw an error if the process failed, or if the process attempts to print anything to stdout.\n"
      ],
      "text/plain": [
       "\u001b[36m  open(f::Function, args...; kwargs...)\u001b[39m\n",
       "\n",
       "  Apply the function \u001b[36mf\u001b[39m to the result of \u001b[36mopen(args...; kwargs...)\u001b[39m and close the\n",
       "  resulting file descriptor upon completion.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> open(\"myfile.txt\", \"w\") do io\u001b[39m\n",
       "\u001b[36m             write(io, \"Hello world!\")\u001b[39m\n",
       "\u001b[36m         end;\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> open(f->read(f, String), \"myfile.txt\")\u001b[39m\n",
       "\u001b[36m  \"Hello world!\"\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> rm(\"myfile.txt\")\u001b[39m\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  open(filename::AbstractString; lock = true, keywords...) -> IOStream\u001b[39m\n",
       "\n",
       "  Open a file in a mode specified by five boolean keyword arguments:\n",
       "\n",
       "  Keyword  Description            Default                          \n",
       "  –––––––– –––––––––––––––––––––– –––––––––––––––––––––––––––––––––\n",
       "  \u001b[36mread\u001b[39m     open for reading       \u001b[36m!write\u001b[39m                           \n",
       "  \u001b[36mwrite\u001b[39m    open for writing       \u001b[36mtruncate | append\u001b[39m                \n",
       "  \u001b[36mcreate\u001b[39m   create if non-existent \u001b[36m!read & write | truncate | append\u001b[39m\n",
       "  \u001b[36mtruncate\u001b[39m truncate to zero size  \u001b[36m!read & write\u001b[39m                    \n",
       "  \u001b[36mappend\u001b[39m   seek to end            \u001b[36mfalse\u001b[39m                            \n",
       "\n",
       "  The default when no keywords are passed is to open files for reading only.\n",
       "  Returns a stream for accessing the opened file.\n",
       "\n",
       "  The \u001b[36mlock\u001b[39m keyword argument controls whether operations will be locked for\n",
       "  safe multi-threaded access.\n",
       "\n",
       "\u001b[39m\u001b[1m  │ \u001b[22m\u001b[39m\u001b[1mJulia 1.5\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m  The \u001b[36mlock\u001b[39m argument is available as of Julia 1.5.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  open(filename::AbstractString, [mode::AbstractString]; lock = true) -> IOStream\u001b[39m\n",
       "\n",
       "  Alternate syntax for open, where a string-based mode specifier is used\n",
       "  instead of the five booleans. The values of \u001b[36mmode\u001b[39m correspond to those from\n",
       "  \u001b[36mfopen(3)\u001b[39m or Perl \u001b[36mopen\u001b[39m, and are equivalent to setting the following boolean\n",
       "  groups:\n",
       "\n",
       "  Mode Description                   Keywords                    \n",
       "  –––– ––––––––––––––––––––––––––––– ––––––––––––––––––––––––––––\n",
       "  \u001b[36mr\u001b[39m    read                          none                        \n",
       "  \u001b[36mw\u001b[39m    write, create, truncate       \u001b[36mwrite = true\u001b[39m                \n",
       "  \u001b[36ma\u001b[39m    write, create, append         \u001b[36mappend = true\u001b[39m               \n",
       "  \u001b[36mr+\u001b[39m   read, write                   \u001b[36mread = true, write = true\u001b[39m   \n",
       "  \u001b[36mw+\u001b[39m   read, write, create, truncate \u001b[36mtruncate = true, read = true\u001b[39m\n",
       "  \u001b[36ma+\u001b[39m   read, write, create, append   \u001b[36mappend = true, read = true\u001b[39m  \n",
       "\n",
       "  The \u001b[36mlock\u001b[39m keyword argument controls whether operations will be locked for\n",
       "  safe multi-threaded access.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> io = open(\"myfile.txt\", \"w\");\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> write(io, \"Hello world!\");\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> close(io);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> io = open(\"myfile.txt\", \"r\");\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> read(io, String)\u001b[39m\n",
       "\u001b[36m  \"Hello world!\"\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> write(io, \"This file is read only\")\u001b[39m\n",
       "\u001b[36m  ERROR: ArgumentError: write failed, IOStream is not writeable\u001b[39m\n",
       "\u001b[36m  [...]\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> close(io)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> io = open(\"myfile.txt\", \"a\");\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> write(io, \"This stream is not read only\")\u001b[39m\n",
       "\u001b[36m  28\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> close(io)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> rm(\"myfile.txt\")\u001b[39m\n",
       "\n",
       "\u001b[39m\u001b[1m  │ \u001b[22m\u001b[39m\u001b[1mJulia 1.5\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m  The \u001b[36mlock\u001b[39m argument is available as of Julia 1.5.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  open(fd::OS_HANDLE) -> IO\u001b[39m\n",
       "\n",
       "  Take a raw file descriptor wrap it in a Julia-aware IO type, and take\n",
       "  ownership of the fd handle. Call \u001b[36mopen(Libc.dup(fd))\u001b[39m to avoid the ownership\n",
       "  capture of the original handle.\n",
       "\n",
       "\u001b[33m\u001b[1m  │ \u001b[22m\u001b[39m\u001b[33m\u001b[1mWarning\u001b[22m\u001b[39m\n",
       "\u001b[33m\u001b[1m  │\u001b[22m\u001b[39m\n",
       "\u001b[33m\u001b[1m  │\u001b[22m\u001b[39m  Do not call this on a handle that's already owned by some other\n",
       "\u001b[33m\u001b[1m  │\u001b[22m\u001b[39m  part of the system.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  open(command, mode::AbstractString, stdio=devnull)\u001b[39m\n",
       "\n",
       "  Run \u001b[36mcommand\u001b[39m asynchronously. Like \u001b[36mopen(command, stdio; read, write)\u001b[39m except\n",
       "  specifying the read and write flags via a mode string instead of keyword\n",
       "  arguments. Possible mode strings are:\n",
       "\n",
       "  Mode Description Keywords                 \n",
       "  –––– ––––––––––– –––––––––––––––––––––––––\n",
       "  \u001b[36mr\u001b[39m    read        none                     \n",
       "  \u001b[36mw\u001b[39m    write       \u001b[36mwrite = true\u001b[39m             \n",
       "  \u001b[36mr+\u001b[39m   read, write \u001b[36mread = true, write = true\u001b[39m\n",
       "  \u001b[36mw+\u001b[39m   read, write \u001b[36mread = true, write = true\u001b[39m\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  open(command, stdio=devnull; write::Bool = false, read::Bool = !write)\u001b[39m\n",
       "\n",
       "  Start running \u001b[36mcommand\u001b[39m asynchronously, and return a \u001b[36mprocess::IO\u001b[39m object. If\n",
       "  \u001b[36mread\u001b[39m is true, then reads from the process come from the process's standard\n",
       "  output and \u001b[36mstdio\u001b[39m optionally specifies the process's standard input stream.\n",
       "  If \u001b[36mwrite\u001b[39m is true, then writes go to the process's standard input and \u001b[36mstdio\u001b[39m\n",
       "  optionally specifies the process's standard output stream. The process's\n",
       "  standard error stream is connected to the current global \u001b[36mstderr\u001b[39m.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  open(f::Function, command, args...; kwargs...)\u001b[39m\n",
       "\n",
       "  Similar to \u001b[36mopen(command, args...; kwargs...)\u001b[39m, but calls \u001b[36mf(stream)\u001b[39m on the\n",
       "  resulting process stream, then closes the input stream and waits for the\n",
       "  process to complete. Return the value returned by \u001b[36mf\u001b[39m on success. Throw an\n",
       "  error if the process failed, or if the process attempts to print anything to\n",
       "  stdout."
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?open"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Base.Condition\n",
      "Base.Slice\n",
      "Base.IteratorEltype\n",
      "Base.prevind\n",
      "Base.nextind\n",
      "Base.LOAD_PATH\n",
      "Base.IteratorSize\n",
      "Base.@nospecialize\n",
      "Base.isequal\n",
      "Base.RangeStepStyle\n",
      "Base.@pure\n",
      "Base.isbitstype\n",
      "Base.:*\n",
      "Base.IndexLinear\n",
      "Base.IndexCartesian\n",
      "Base.reduce\n",
      "Base.isconcretetype\n",
      "Base.isbitsunion\n",
      "Base.isdispatchtuple\n",
      "Base.:∘\n",
      "Base.Multimedia.display\n",
      "Base.IRShow.compute_ir_line_annotations\n",
      "Base.Broadcast.newindex\n",
      "Base.Sys.isbsd\n",
      "Base.Threads.atomic_cas!\n",
      "Base.CoreLogging.@warn\n",
      "Base.CoreLogging.@info\n",
      "Base.CoreLogging.@debug\n",
      "Base.CoreLogging.@error\n",
      "Base.CoreLogging.@logmsg\n",
      "Base.sortperm\n",
      "Base.Sort.partialsortperm\n",
      "Base.Experimental.register_error_hint\n",
      "NetworkOptions.ssh_key_pass\n",
      "LinearAlgebra.ZeroPivotException\n",
      "Base.sqrt\n",
      "LinearAlgebra.LAPACK.gesvx!\n",
      "Base.randn\n",
      "Random.randn!\n",
      "Tar.tree_hash\n",
      "LibGit2.BlameOptions\n",
      "LibGit2.isbare\n",
      "LibGit2.DiffOptionsStruct\n",
      "LibGit2.treewalk\n",
      "LibGit2.clone\n",
      "Profile.fetch\n",
      "SparseArrays.sprand\n",
      "REPL.TerminalMenus.MultiSelectMenu\n",
      "Statistics.middle\n",
      "Statistics.var\n",
      "Statistics.varm\n",
      "Statistics.mean\n",
      "Statistics.stdm\n",
      "Statistics.median\n",
      "Statistics.std\n",
      "Statistics.mean!\n",
      "Test.@testset\n",
      "Test.test_expr!\n",
      "Downloads.Response\n",
      "Parsers.Options\n",
      "IJulia.set_cur_msg\n"
     ]
    }
   ],
   "source": [
    "apropos(\"mean\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "using DelimitedFiles\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1me\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1md\u001b[22m\u001b[0m\u001b[1md\u001b[22mir\n",
      "\n",
      "Couldn't find \u001b[36mreaddlm\u001b[39m\n",
      "Perhaps you meant readdir, read, read!, real or readchomp\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "No documentation found.\n",
       "\n",
       "Binding \\texttt{readdlm} does not exist.\n",
       "\n"
      ],
      "text/markdown": [
       "No documentation found.\n",
       "\n",
       "Binding `readdlm` does not exist.\n"
      ],
      "text/plain": [
       "  No documentation found.\n",
       "\n",
       "  Binding \u001b[36mreaddlm\u001b[39m does not exist."
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?readdlm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"/home/abarth/Lectures/JuliaTutorial\""
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The file system\n",
    "\n",
    "* On every current operating system, files are organized in a tree of directories starting from a root directory\n",
    "* The absolute path of a directory or file defines which directories to follow starting from the root directory to the given directory or file\n",
    "* In Linux/UNIX/Max OS X, files and directory names are separated by a slash (/), on Windows by a backslash (\\\\)\n",
    "* In order to avoid to deal with long path names, every program has a current working directory\n",
    "* The current working directory from Julia can be queried with the command `pwd()`.\n",
    "* The relative path of a directory or file defines which directories to follow starting from the current directory to the given directory or file\n",
    "* In relative path, two dots (`..`) represent the parent directory.\n",
    "* To change the current directory, you can use the command `cd`. For Linux and Mac OS X:\n",
    "\n",
    "```julia\n",
    "cd(\"/home/MyDir\")\n",
    "``` \n",
    "\n",
    "Under Windows you need to you the following:\n",
    "\n",
    "```julia\n",
    "cd(\"C:\\\\Users\\\\MyDir\")\n",
    "```\n",
    "\n",
    "Note that here two backslashes are necessary ([why?](https://stackoverflow.com/questions/28328052/why-do-i-have-to-use-double-backslashes-for-file-paths-in-code))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing/Exporting data\n",
    "\n",
    "## ASCII format\n",
    "\n",
    "* To read ASCII data in Julia, tables should be saved as an ASCII text file using space or a special characters as separator. Each line corresponds to one row. Make sure that a dot is used as a decimal separator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8784×8 Matrix{Float64}:\n",
       " 2004.0   1.0   1.0   0.0  0.0   0.297  0.003  0.0\n",
       " 2004.0   1.0   1.0   1.0  0.0   0.302  0.002  0.0\n",
       " 2004.0   1.0   1.0   2.0  0.0   0.295  0.006  0.0\n",
       " 2004.0   1.0   1.0   3.0  0.0   0.28   0.003  0.0\n",
       " 2004.0   1.0   1.0   4.0  0.0   0.236  0.004  0.0\n",
       " 2004.0   1.0   1.0   5.0  0.0   0.192  0.003  0.0\n",
       " 2004.0   1.0   1.0   6.0  0.0   0.164  0.002  0.0\n",
       " 2004.0   1.0   1.0   7.0  0.0   0.153  0.003  0.0\n",
       " 2004.0   1.0   1.0   8.0  0.0   0.126  0.002  0.0\n",
       " 2004.0   1.0   1.0   9.0  0.0   0.094  0.002  0.0\n",
       " 2004.0   1.0   1.0  10.0  0.0   0.067  0.002  0.0\n",
       " 2004.0   1.0   1.0  11.0  0.0   0.069  0.002  0.0\n",
       " 2004.0   1.0   1.0  12.0  0.0   0.08   0.001  0.0\n",
       "    ⋮                            ⋮             \n",
       " 2004.0  12.0  31.0  12.0  0.0   0.078  0.003  0.0\n",
       " 2004.0  12.0  31.0  13.0  0.0   0.031  0.002  0.0\n",
       " 2004.0  12.0  31.0  14.0  0.0  -0.002  0.005  0.0\n",
       " 2004.0  12.0  31.0  15.0  0.0  -0.025  0.001  0.0\n",
       " 2004.0  12.0  31.0  16.0  0.0  -0.037  0.004  0.0\n",
       " 2004.0  12.0  31.0  17.0  0.0  -0.029  0.004  0.0\n",
       " 2004.0  12.0  31.0  18.0  0.0   0.012  0.004  0.0\n",
       " 2004.0  12.0  31.0  19.0  0.0   0.018  0.001  0.0\n",
       " 2004.0  12.0  31.0  20.0  0.0   0.085  0.003  0.0\n",
       " 2004.0  12.0  31.0  21.0  0.0   0.106  0.01   0.0\n",
       " 2004.0  12.0  31.0  22.0  0.0   0.142  0.004  0.0\n",
       " 2004.0  12.0  31.0  23.0  0.0   0.199  0.007  0.0"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using DelimitedFiles\n",
    "data  = readdlm(\"8762075.sealevel.txt\",comments = true,comment_char='%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Saving the variable data in the file data.txt using the ASCII format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "writedlm(\"data.txt\",data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NetCDF format\n",
    "\n",
    "* Reading a variable called `var`  from a NetCDF file\n",
    "\n",
    "```julia\n",
    "using NCDatasets\n",
    "ds = Dataset(\"file.nc\")\n",
    "data = ds[\"var\"][:];\n",
    "close(ds)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Writing a variable called `var` data to a NetCDF file\n",
    "\n",
    "```julia\n",
    "ds = Dataset(\"file.nc\",\"c\")\n",
    "\n",
    "# Define the dimension \"lon\" and \"lat\" with the size 100 and 110 resp.\n",
    "defDim(ds,\"lon\",100)\n",
    "defDim(ds,\"lat\",110)\n",
    "\n",
    "\n",
    "# Define the variables temperature and salinity\n",
    "v = defVar(ds,\"temperature\",Float32,(\"lon\",\"lat\"))\n",
    "# write a the complete data set\n",
    "v[:,:] = data\n",
    "close(ds)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scripts\n",
    "\n",
    "* A series of commands can be collected in a script file\n",
    "* A script file has the extension `.jl`\n",
    "* How can Julia find your script file?\n",
    "    * it must be either in your current work directory\n",
    "    * the directory containing the script file must be added to the search path using `LOAD_PATH`. For example\n",
    "\n",
    "```julia\n",
    "push!(LOAD_PATH,\"/some/path\")\n",
    "```\n",
    "\n",
    "* The code in a script is executed when using `include`:\n",
    "\n",
    "```\n",
    "include(\"filename.jl\")\n",
    "```\n",
    "\n",
    "\n",
    "# Functions\n",
    "\n",
    "* Functions are similar to scripts\n",
    "* Unlike scripts, functions can have input/output parameters\n",
    "* For example a function calculating the speed of ocean current based on the zonal and meridional component"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "current_speed (generic function with 1 method)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function current_speed(u,v)\n",
    "   speed = sqrt(u^2 + v^2)\n",
    "   return speed\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0710678118654755"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speed2 = current_speed(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.830951894845301"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speed = current_speed(3,5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 5.830951894845301\n",
       " 4.242640687119285\n",
       " 5.656854249492381"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speed = current_speed.([3,3,4],[5,3,4])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length(findall(P .== 0)) = 5\n",
      "sum(P .== 0) = 5\n",
      "count(P .== 0) = 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P = [0,0,0,3,4,5,3,0,0]\n",
    "\n",
    "@show length(findall(P .== 0))\n",
    "@show sum(P .== 0)\n",
    "@show count(P .== 0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's sunny"
     ]
    }
   ],
   "source": [
    "precipitation = 0\n",
    "if precipitation == 0\n",
    "    print(\"It's sunny\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "withoutrain (generic function with 1 method)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P = [0,0,0,3,4,5,3,0,0]\n",
    "\n",
    "function withoutrain(P)\n",
    "    for i = 1:9\n",
    "       @show i,P[i]\n",
    "    end\n",
    "    return 5\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "days = 1\n",
      "days = 2\n",
      "days = 3\n",
      "days = 3\n",
      "days = 3\n",
      "days = 3\n",
      "days = 3\n",
      "days = 4\n",
      "days = 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function dayswithoutrain(P)\n",
    "    #....\n",
    "    days = 0\n",
    "    for i = 1:length(P)\n",
    "        # do something with i\n",
    "        if P[i] == 0\n",
    "            # count\n",
    "            days = days+1\n",
    "        end\n",
    "        @show days\n",
    "    end    \n",
    "    return days\n",
    "end    \n",
    "days = dayswithoutrain(P)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PyPlot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules\n",
    "\n",
    "Functions can be grouped into a module. \n",
    "\n",
    "## Installation of modules\n",
    "\n",
    "To install a module use `Pkg.add`, for example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```julia\n",
    "using Pkg\n",
    "Pkg.add(\"PyPlot\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A module can be upgraded with:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```julia\n",
    "Pkg.update(\"PyPlot\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A no-longer used module can be removed with `Pkg.rm(\"ModuleName\")`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using modules\n",
    "\n",
    "To access a function (e.g. the function `plot`) inside a module (e.g. `PyPlot`) one need to load the module with `using`. The following loads the module `PyPlot`:\n",
    "\n",
    "```julia\n",
    "using PyPlot\n",
    "```\n",
    "\n",
    "Now the function `plot` can be called.\n",
    "Alternatively, one can also use `import`:\n",
    "\n",
    "```julia\n",
    "import PyPlot\n",
    "```\n",
    "The function plot can be called as `PyPlot.plot`. The import statement is useful to indicate in the source code the origin of the different functions (and avoid possible naming conflicts).\n",
    "\n",
    "A short summary of a module is generally available by issuing\n",
    "\n",
    "```julia\n",
    "?ModuleName\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot([10,20,30],[1,2,3],\"b.-\",label=\"first plot\")\n",
    "plot([10,20,30],[2,3,4],\"rx-\",label=\"second plot\")\n",
    "legend()\n",
    "savefig(\"my_figure.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dates\n",
    "\n",
    "* Julia has a structure called `DateTime` to represent a date and time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1999-12-31T23:59:59"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Dates\n",
    "lastsecond = DateTime(1999,12,31,23,59,59)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The difference between two `DateTime`s returns a structure representing the number of milliseconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2001-01-01T00:00:00"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DateTime(2001,1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "366 days"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Dates.Day(DateTime(2001,1,1) - DateTime(2000,1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Convert this in days:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "366 days"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "Dates.Day(DateTime(2001,1,1) - DateTime(2000,1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* add a duration to a date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2022-01-14T00:00:00"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DateTime(2021,10,6) + Dates.Day(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In how many days is your next birthday?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "\n",
    "* Let your computer do repetitive tasks!\n",
    "* Loops have a counter which takes successively all elements of a row vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i = 1\n",
      "i = 2\n",
      "i = 10\n",
      "i = 20\n"
     ]
    }
   ],
   "source": [
    "for i = [1, 2, 10, 20]\n",
    "    @show i\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Loops are often used with a range of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i = 1\n",
      "i = 2\n",
      "i = 3\n",
      "i = 4\n",
      "i = 5\n"
     ]
    }
   ],
   "source": [
    "for i = 1:5\n",
    "  @show i\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Explicit loops can sometimes be avoided:\n",
    "* For example, sum all integer from 1 to 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(i, total) = (1, 1)\n",
      "(i, total) = (2, 3)\n",
      "(i, total) = (3, 6)\n",
      "(i, total) = (4, 10)\n",
      "(i, total) = (5, 15)\n",
      "(i, total) = (6, 21)\n",
      "(i, total) = (7, 28)\n",
      "(i, total) = (8, 36)\n",
      "(i, total) = (9, 45)\n",
      "(i, total) = (10, 55)\n",
      "total = 55\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function sumupto(N)\n",
    "   total = 0;\n",
    "   for i = 1:N\n",
    "        total = total + i;\n",
    "        @show i,total\n",
    "   end\n",
    "    @show total\n",
    "    return total\n",
    "end\n",
    "S = sumupto(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(findall(P .== 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can simply be computed as `sum(1:10)`.\n",
    "\n",
    "# if-statement\n",
    "\n",
    "* Sometimes your code needs to behave differently depending on some conditions.\n",
    "\n",
    "* if-statement has the following structure.\n",
    "\n",
    "```julia\n",
    "if some_conditions\n",
    "  # do something\n",
    "else\n",
    "  # do something else\n",
    "end\n",
    "```\n",
    "The else section can be omitted.\n",
    "\n",
    "For example.\n",
    "\n",
    "```julia\n",
    "if x < 0\n",
    "   x = -x;\n",
    "end\n",
    "```\n",
    "\n",
    "* Which Julia function implements the last code example?"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.8.0",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}