Tutorial_solutions_part1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [NM2018] Numerical computing in Python tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "60934ae2-267e-49ad-83dd-3a99157a4d91"
    }
   },
   "source": [
    "_Leo van Kampenhout — Institute for Marine and Atmospheric physics Utrecht (IMAU) — [email](mailto:L.vankampenhout@uu.nl) — [website](http://www.uu.nl/staff/LvanKampenhout/0)_ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "d45aa25e-120e-4742-8041-29a648aa41a8"
    }
   },
   "source": [
    "This tutorial starts with some background information on how numbers are internally represented on modern computers. Then we discuss Python language specifics and how to implement *logic* and *flow control*. The numerical library ***Numpy*** is then introduced and we finish by learning how to make plots using ***Matplotlib***.\n",
    "\n",
    "A more complete overview of the capabilities of Python, Numpy and Matplotlib can be found online in the [Lectures on scientific computing with Python](http://jrjohansson.github.io/computing.html) by J.R. Johansson. It is suggested that you use these lectures as a reference.\n",
    "\n",
    "\n",
    "The exercises are to be done individually, in class or at home. I recommend working in either the Spyder IDE or in a interactive Jupyter notebook, both of which come with the Anaconda Python distribution: https://www.continuum.io/downloads."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 0 - calculator\n",
    "Python can be used as a calculator by just entering arithmetic statements in an interactive session, like in a IPython console (Spider IDE) or a Jupyter notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5 + 2) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following operators are available: \n",
    "\n",
    "operation | symbol\n",
    "--- | :---:\n",
    "addition | `+`\n",
    "subtraction | `-`\n",
    "multiplication | `*`\n",
    "division  | `/`\n",
    "power | `**`\n",
    "integer division | `//`\n",
    "modulo | `%`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The scientific `e` notation is supported, where `2e13` means $2 \\cdot 10^{13}$ and `3e-4` means $3 \\cdot 10^{-4}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2e13 == 2*10**13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Heads up.** In Jupyter, if you enter multiple statements at once, only the result of the last statement will be returned. There are a number of ways around that:\n",
    "\n",
    "* wrap the statements in the `print()` built-in function, which displays the answer as text\n",
    "* separate the statements by commas\n",
    "* create a new cell for each statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1\n",
    "2+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(1+1)\n",
    "print(2+2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1, 2+2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inline comments can be added and must be preceded by the '#' sign."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(1+1) # trivial calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1 - Data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "b41c45bd-6eff-44bd-a8a0-274288995252"
    }
   },
   "source": [
    "## Bits and bytes\n",
    "Present-day computers are binary machines that operate on information that is base 2, which means that the information is expressed in just zeros and ones. The smallest entity of binary information is the *bit*. The bit consists of just a single binary digit and therefore can have only two states: 0 or 1. Eight bits taken together make up a *byte*, which is the second smallest entity of binary information. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "2b83e79c-e4b5-46b2-9651-82e90f2f83a5"
    }
   },
   "source": [
    "**Example.** Consider the byte 01101011 and let's assume it represents a number. Starting from the right, the first `1` encoutered corresponds to $2^0 = 1$, just like the last digit in a decimal number corresponds to $10^0 = 1$. The second rightmost digit (`1`) multiplies with $2^1 = 2$. The encoded numerical value of this byte is therefore:\n",
    "\n",
    "$0 \\cdot 2^7 + 1 \\cdot 2^6 + 1 \\cdot 2^5 + 0 \\cdot 2^4 + 1 \\cdot 2^3 + 0 \\cdot 2^2 + 1 \\cdot 2^1 + 1 \\cdot 2^0 = 107$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Exercise 1.1 (bytes)** \n",
    "1. What is the largest numerical value you can encode in a byte this way?\n",
    "2. What is the total number of possible states for the byte? \n",
    "3. The Latin alphabet as used in The Netherlands has 26 characters ('states'). Considering both lower and upper case characters and 30 punctuation marks, is the byte large enough to encode the alphabet? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Answers***\n",
    "1. $2^7 + 2^6 + .. + 2^0 = 255 = 2^8-1$\n",
    "2. $2^8 = 256$\n",
    "3. yes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "266eb26d-a8f2-4159-a806-16b1754bea9f"
    }
   },
   "source": [
    "## Floating point numbers\n",
    "In scientific computing, we are not so much interested in characters but rather in decimal numbers (base 10 or ’real’ numbers) that we can relate to the physical world. For these kind of computations, a byte does not offer enough data states or *precision*, so larger data types are needed. Note that here ’data’ is synonymous to ’information’ and ’type’ to ’entity’ – this is the lingo that computer scientists use.\n",
    "\n",
    "Typically, real numbers on a computer are made up of either 4 bytes (single precision) or 8 bytes (double precision), which correspond to 32 or 64 bits, respectively. Real numbers encoded in this binary form are referred to as _floating point numbers_ or simply _floats_. In standard Python, the `float` datatype is of double precision. \n",
    "\n",
    "In the Numpy library, which will be discussed in-depth later, different floating point data types are named after their bitsize: `float32` for single precision and `float64` for double precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.float32, 4, numpy.float64, 8)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "x=np.float32(1) # create variable of type float32\n",
    "y=np.float64(1) # create variable of type float64\n",
    "type(x), x.nbytes, type(y), y.nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "f464431d-3e07-4383-bbd2-064364f56adf"
    }
   },
   "source": [
    "**Example.** Note that we can rewrite $110.1001$ as $1.101001 \\cdot 2^2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "0dbbaa8a-6bdb-41aa-be64-36cf386fbf2e"
    }
   },
   "source": [
    "Now let us write any binary floating point number as\n",
    "$$\\pm 1.m \\cdot 2^e$$\n",
    "with ***mantissa*** m (’significant digits’) and exponent e. Note that this resembles the scientific notation of a decimal number, except that here the base is different (2 instead of 10). Of the 32 bits of a `float32` number, 1 bit is reserved for the sign, 23 bits for the mantissa, and the remaining 8 make up the exponent. Note that the effective precision of the mantissa is 24 bits because the leading binary ’1’ of the mantissa is implicit (Eqn. (1)). The `float` and `float64` have an effective mantissa of 53 bits and an exponent of 11 bits. The base number need not be stored since it is assumed the same on all modern computers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![wikipedia](https://upload.wikimedia.org/wikipedia/commons/thumb/d/d2/Float_example.svg/590px-Float_example.svg.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "161cc24b-dd33-49c9-93b0-2ee602f9069d"
    }
   },
   "source": [
    "**Exercise 1.2 (floats)**\n",
    "Naturally, there are certain limitations to the precision of the mantissa and the range of the exponent. In this exercise we explore these limitations.\n",
    "\n",
    "1. How many permutations or different states does a 24-bit mantissa have?\n",
    "\n",
    "2. With one decimal digit one can produce 10 numbers (0-9). With two available digits this grows to 100. How many decimal numbers can one encode with a 24-bit mantissa?\n",
    "3.  A double precision floating point number has an effective mantissa of 53 bits. How many decimal numbers can one encode with this?\n",
    "4. Execute the following commands in interactive mode (IPython console):\n",
    "```\n",
    " 1.0 + 1e-15\n",
    " 1.0 + 1e-16\n",
    "```\n",
    "which are by default performed in 64-bits (double precision). Explain the results using your answer at part (c).\n",
    "5. In order to be useful, the 8-bit exponent must cover both negative (’small’) to positive (’big’) values. This means that 1 bit has to be reserved for the exponent sign, and we are effectively left with just 7 bits. What is the number of permutations or states one can make with 7 bits?\n",
    "1. Verify that the largest decimal number one can make with a 7-digit binary exponent is around $10^{38}$. Take into account the base change. What is the largest decimal number one can make in double precision?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.000000000000001"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0 + 1e-15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0 + 1e-16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Answers.***\n",
    "\n",
    "1. $2^{24}$ = 16777216 different states\n",
    "2. 10 states = 1 decimal digit, 100 states = 2 decimal digits, so 16777216 states ~= 7 digits. You may also calculate this as $\\log_{10}(2^{24}) = \\frac{\\ln(2^{24})}{\\ln(10)}$ = `np.log(2**24) / np.log(10)` = 7.22. This means that the accuracy of the mantissa is no more than 7 digits.\n",
    "3. Number of states is $2^{54}$. Number of decimal numbers ~ $\\log_{10}(2^{54})$ ~ 16 digits. This means that the accuracy of the mantissa is no more than 16 digits for a 64-bit floating point.\n",
    "4. The number 1e-16 cannot be added to 1, because the resulting number would require 17 digits. The result is silently rounded to the nearest number that can be represented, which is 1.\n",
    "5. $2^7 = 128$, so the exponent ranges from -128 to +128, approximately. \n",
    "6. The largest possible exponent $e$ is 128. The largest number $1.m \\cdot 2^e$ you can make is therefore ~ $2^{128} = 10^x$. Taking the logarithm (base 10) on both sides yields $x=38.5$. For double precision with an 11 bits exponent this changes to $x=308$. (Numpy seems to have a problem with calculating this; using `math.log` works though -- see below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.2247198959355474"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(2.**24)/np.log(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.255619765854984"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(2.**54)/np.log(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38.531839444989586"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(2.**128)/np.log(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "308.2547155599167"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.log(2.**(2.**10))/np.log(10.) # overflow error\n",
    "import math\n",
    "#math.log(2.**1024,10) # overflow error\n",
    "math.log(2**1024,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1e+308, inf)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1e308, 1e309"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "c45c8e0d-2213-402f-a165-c5c7d10d1f48"
    }
   },
   "source": [
    "**Remark.** When the limits of the exponent are exceeded, a floating point number becomes infinite (’inf’) or not-a-number (’NaN’). Just be aware that this can happen, and remember that it usually indicates a programming error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0e400 # 1 * 10^400"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "0274bf66-1b2f-4cf0-b593-2617bdea44d0"
    }
   },
   "source": [
    "## Integers\n",
    "Just as the floating point numbers are the computer representation of $\\mathbb{R}$, the set of whole-valued numbers $\\mathbb{Z}$ is represented in the data type of integers. In numerical computing, integers are often just used in trivial ways, so we won’t go into their details here. It suffices to say that like floating points, there are 32-bit integers (Python: `np.int32`) and 64-bit integers (`int`, `np.int64`).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "1182525c-6a0a-4c67-99a5-1dac85a08823"
    }
   },
   "source": [
    "## Variables\n",
    "A variable is not a data type, rather it the feature by which names can be used to store any data type -- even data types that you may have created yourself. Some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "nbpresent": {
     "id": "39b4ff27-c371-479b-9132-7c28178a76e7"
    }
   },
   "outputs": [],
   "source": [
    "x = 1.0\n",
    "y = 10 \n",
    "z = x*2 \n",
    "do_work = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "97288d2b-31b0-492c-9e74-136d8431f5d0"
    }
   },
   "source": [
    "Here we defined a floating point variable (`x`), an integer variable (`y`), another floating point variable (`z`) and finally a boolean (`do_work`) variable. We did not need to declare the type of the variable prior to defining it, as Python uses dynamical typing for that (it infers the data type from the assigned value). One can inspect the data type of a variable by calling the built-in function `type()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "nbpresent": {
     "id": "b986c7bd-45b5-4fbf-a425-bbb242845f04"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "15f4f6d1-c135-4c78-9821-cc570205b0b6"
    }
   },
   "source": [
    "**Remark.** There are two simple rules about the naming of variables. First, they should always start with an alphabetic character. Second, words used by the Python language are reserved. These names can be found by calling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "nbpresent": {
     "id": "6a76ba0f-ec75-4952-8926-7e5ee49bf893"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A character string or simply _string_ is a data type encoding text, which is useful for labelling plots, writing diagnostic output, etc. In Python, a string is created whenever text is enclosed between ' or \" quotes. Strings can be concatenated as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdef'"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc' + 'def'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 1.3 (strings)**\n",
    "1. Define a new variable named s that has the value `’This is a string’`\n",
    "2. Count the number of characters in s using the function `len()`\n",
    "3. Evaluate `s.split()`. What does this function do?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Answers***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, ['this', 'is', 'a', 'string'])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'this is a string'\n",
    "len(s), s.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 16 characters. `s.split()` splits the string into a list of the separate words."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists and tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The list data type is particular to Python, and very useful. Lists are denotes by square brackets `[]` and can store any kind of other data, and also mixed data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 'hello', 10.10]\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many useful library functions exist that can take lists as input, or return a list as output. A tuple is the same as a list, except that it is immutable: the contents may not change after its definition. Tuples are denoted by round brackets `()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tuple, 5)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (1, 'hello', 10.10, 'there', 55)\n",
    "type(x), len(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elements in lists, tuples can be selected by _indexing_ the variable. Indexing is denoted with square brackets `[]` right after the variable name (no space).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the indexing is zero-based, which means that the first element in the list or tuple has index 0, the second element index 1, etc. Indexing from the rear is also possible with negative indices (-1, -2, ...). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple elements can be selected by the `:` operator, which signals a range. The starting point is included but not the endpoint. This is comparable to the mathematical notation for domains `[a,b)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'hello')"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 1.4 (Calculations with lists)** \n",
    "1. Define a new list named `yk` with values `1, -1, 8, 3, 2, 0.5, -1.5`.\n",
    "2. Find the number of list elements using the `len()` built-in\n",
    "3. Find the minimum and maximum using `min()`\n",
    "and `max()` built-ins\n",
    "4. The mean of sequence `yk` is given by\n",
    "$$\\overline{y} = \\frac{1}{n}\\sum_{k=1}^{n} y_k.$$ \n",
    "Calculate $\\overline{y}$, making use of the `sum()` built-in.\n",
    "5. Verify that the mean of the last four elements of $y$ is 1.0. Use negative indices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Answers***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7, -1.5, 8, 1.7142857142857142)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yk = 1,-1,8,3,2,0.5,-1.5\n",
    "len(yk), min(yk), max(yk), sum(yk)/len(yk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(yk[-4:])/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Booleans\n",
    "The _boolean_ (named after George Boole, a 19th century British mathematician) is the logical data type. A boolean can have two states: it is either `True` or `False`. Therefore, it can be internally represented by just a single bit (see the section on bits and bytes). \n",
    "\n",
    "Booleans are indispensible when building logic into your code. For instance, consider the following piece of code:\n",
    "```python\n",
    "if (x<0): \n",
    "   y=0\n",
    "else:\n",
    "   y = x**2\n",
    "```\n",
    "which is the Python equivalent of\n",
    "\\begin{eqnarray*}\n",
    "y(x) =\n",
    "\\begin{cases}\n",
    "x^2 \\qquad & \\mathrm{if} \\; x \\geq 0 \\\\\n",
    "0   \\qquad & \\mathrm{if} \\; x \\lt 0. \\\\\n",
    "\\end{cases}\n",
    "\\end{eqnarray*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The if-statement takes a boolean value as input which it uses to decide which of the two different branches to enter. In this case the boolean is calculated by `x<0`. We could also have written `if (True)` but that is rather trivial and does not help in building logic.\n",
    "\n",
    "As in the example above, booleans can be constructed from numerical values using **comparison operators** `<`, `>`, `<=`, `=>`, `==`. Further, booleans can be combined in various ways using the keywords `and`, `or`, `not`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True and True) \n",
    "print(True and False)\n",
    "print(True or False)\n",
    "print(not True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2 - flow control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flow control is all about structuring your code in logical units. This has two goals, namely A) to make the code behave like it should, and B) in order to avoid code duplication. In other words, we generally always would like to write code that is as short as possible while still performing the task at hand, with little to no duplicate code. For instance, the evaluation of a mathematical function can be done in a Python function (keyword `def`, see below). \n",
    "\n",
    "These logical units of code are called ***code blocks*** and they can be recognized by their *indentation level*. One indentation level consists of a tab or four white spaces. \n",
    "\n",
    "```python\n",
    "# base level \n",
    "def func(do_work):\n",
    "    # indentation level 1\n",
    "    if (do_work):\n",
    "        #indentation level 2\n",
    "        (...)\n",
    "    else:\n",
    "        #indentation level 2 again\n",
    "        pass # empty code block is indicated by 'pass'\n",
    "   \n",
    "    # back to level 1   \n",
    "    print('function func() has finished')   \n",
    "```\n",
    "**Remark.** Realize that indentation is critical to the execution of the code. Failing to indent correctly may lead to errors or, worse, the behaviour of the code is unknowingly incorrect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, conditional branching is done using the `if`, `elif` (\"else if\") and `else` statements. Each of these statements must be followed by a code block. Not all branches have to be present at the same time though. \n",
    "\n",
    "```python\n",
    "if (s[0] == 'A'):\n",
    "    print('first character of s is an A')\n",
    "elif (s[0] == 'B'):\n",
    "    print('first character of s is an B')\n",
    "elif (s[0] == 'C'):\n",
    "    print('first character of s is an C')\n",
    "else:\n",
    "    print('first character of s is not any of A,B,C')\n",
    "```\n",
    "\n",
    "**Exercise 2.1 (conditionals)** Consider the same function as before\n",
    "\\begin{eqnarray*}\n",
    "y(x) = \n",
    "\\begin{cases}\n",
    "x^2 \\qquad & \\mathrm{if} \\; x \\geq 0; \\\\\n",
    "0   \\qquad & \\mathrm{if} \\; x < 0\n",
    "\\end{cases}\n",
    "\\end{eqnarray*}\n",
    "We write this into executable code by assigning some random value to `x`. The resulting `y` should to be printed to the screen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -1\n",
    "if (x<0): \n",
    "    y=0\n",
    "else:\n",
    "    y = x**2\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example the `print` is not executed when `x<0`. \n",
    "1. Repair the code above such that `y` is always printed.\n",
    "2. Write code that implements this function:\n",
    "\\begin{eqnarray*}\n",
    "y(x) = \n",
    "\\begin{cases}\n",
    "x^3 \\qquad & \\mathrm{if} \\; x \\geq 1; \\\\\n",
    "x^2 \\qquad & \\mathrm{if} \\; 0 \\leq x < 1; \\\\\n",
    "\\sqrt(-x)   \\qquad & \\mathrm{if} \\; x < 0\n",
    "\\end{cases}\n",
    "\\end{eqnarray*}\n",
    "using boolean logic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "Computers are extremely well suitable for automizing repetitive tasks. In case the repetitive task consists of applying a single operation (arithmetical or otherwise) to many elements (say numbers), a _loop_ can be used to automate the process. The process of automizing this is called _looping_ or _iterating_. One cycle of the loop is called an _iteration_.\n",
    "\n",
    "There are two types of loops: `for`-loops and `while`-loops. A `for`-loop is used when the number of elements (and therefore iterations) is fixed and known at the start. This is the loop type that we will mostly use. The other loop type is the `while`-loop, that can be used to create a conditional loop, that only ends when a certain condition is met (say convergence of an algorithm). \n",
    "\n",
    "**Example.** Given a set of numbers, all of which need to be multipled by 2. You can store the numbers in a list and \"loop over\" the list, which means you take one number at the time until the list has no more elements. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "2\n",
      "6\n",
      "12\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "xlist = [4, 1, 3, 6, 0]\n",
    "for x in xlist:\n",
    "    print(x*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other languages like Fortran or C, `for`-loops are typically performed over a certain monotonous range of numbers, rather than a list. This behaviour can be emulated by using the `range()` built-in, which yields a list with numbers based on start and end point, and optionally, a step size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(11))    # range(stop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(2,11))  # range(start,stop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(2,11,2)) # range(start,stop,step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2.2 (strings & loops)** \n",
    "1. Create a string `s` that contains the following sentence: ”lists and tuples are useful for storing data”. \n",
    "2. Use the `s.split()` command to separate the individual words and put them in a list. Store this list as a variable called `s_split`.\n",
    "3. Use the `len()` built-in to find the number of words.\n",
    "2. Write a `for`-loop that iterates every word in the list, and prints it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2.3 (list comprehensions)**\n",
    "A Python _list comprehension_ is a quick and elegant way to create lists based on a formula. It uses a `for` loop to determine the number of elements. \n",
    "\n",
    "Let us define a list `fk` that is given by the quadratic polynomial\n",
    "$$f_k = 5 + 2k - 2k^2$$\n",
    "where $k \\in [0,1,\\ldots,12]$. The corresponding list comprehension is given below. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "fk_ = [5 + 2*k - 2*k**2 for k in range(0,13)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write your own `for`-loop that implements the polynomial. Start with an empty list `fk = []` and iteratively add elements to this list using `fk.append()`. In total you'll need 3 lines of code. Compare the result to the list comprehension `fk_`.\n",
    "2. Write a `for`-loop to compute the sum of elements in fk. Check your answer with the `sum()` built-in.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2.4 (while-loop)** A typical `for`-loop has a fixed number of iterations that is known at the start of the loop. In contrast, the number of iteration in a `while`-loop is not known a priori. It uses a stopping criterion to determine when to break the loop.\n",
    "1. The Fibonacci sequence is given by the equations:\n",
    "\\begin{eqnarray*}\n",
    "\\label{Fibonacci}\n",
    "F_0 &=& 1 \\\\\n",
    "F_1 &=& 1 \\\\\n",
    "F_k &=& F_{k-2} + F_{k-1}\n",
    "\\end{eqnarray*}\n",
    "Using `while`, write Python code that displays all Fibonacci numbers that are lower than 1000. _Hint:_ lists are useless here. Instead, use three scalar variables `fk`, `fkm1`, and `fkm2` (m = minus).\n",
    "2. Add code to verify that the sum of Fibonacci numbers lower than 1000 is 2583."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions \n",
    "Functions are useful in organizing code and making code re-usable. For example, certain arithmetic calculations are applied at various stages in a program. These calculations may be separated out in a function, thus avoiding code duplication and makeing the code more readable.\n",
    "\n",
    "In Python, a function is defined by the keyword `def`, follwed by a function name, input arguments (if any), and a colon `:`. The following code, with one additional level of indentation, is the function body. The function may have a return value (see below) but this is not required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def test_func(x):\n",
    "    return x**2\n",
    "test_func(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2.5 (functions)**\n",
    "Recall the quadratic polynomial \n",
    "$$f_k = 5 + 2k - 2k^2.$$ \n",
    "Before, we evaluated this function only with integer values. We may rewrite it as\n",
    "$$f(x) = 5+2x−2x^2$$\n",
    "where now $x \\in \\mathbb{R}$. \n",
    "1. Write this as a function named `fx`. Verify that\n",
    "`f(3.5) = −12.5`.\n",
    "2. Write another function `ffx` that calculates $f^2(x) = f(f(x))$. Re-use the code that you wrote under (1). Verify that $f^2(1.0)) = -35$. \n",
    "3. Write a function `gx` that calculates $g(x) = f(x) \\cdot f^2(x) + 1$. Re-use `fx` and `ffx`. Verify that $g(-1) = 6.0$.\n",
    "4. Write a function `func_tuple` that given $x$, returns the tuple $(f(x), f^2(x), g(x))$. Re-use previous code.\n",
    "5. Re-define the function `fx` to\n",
    "\\begin{equation}\n",
    "f(x) = 2 + 0.04 x^2.\n",
    "\\end{equation}\n",
    "Verify that `func_tuple(5)` now yields `(3.0, 2.36, 8.08)`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark.** The previous exercise illustrates the power that functions have. Changing a single function definition (in this case, `fx`) triggered other functions (`ffx`, `gx`, `func_tuple`) to also behave differently. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 3 - Numpy and matplotlib\n",
    "The [Numpy library](https://docs.scipy.org/doc/numpy/index.html) is great for linear algebra and doing numerical computations efficiently, so we’ll use it heavily during this course. \n",
    "\n",
    "The [Matplotlib library](http://matplotlib.org/) is the golden standard for scientific plotting in Python. It co-operates well with Numpy, meaning that you can directly plot Numpy vectors in Matplotlib. Find an example below of how seamlessly they integrate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# required for inline displaying of figures in Jupyter\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11a0dfd68>]"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x119e9b5f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x=np.linspace(0,4*np.pi,25)\n",
    "plt.plot(x,np.sin(x),'s-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy cheatsheet\n",
    "\n",
    "### Array creation\n",
    "------\n",
    "\n",
    "command|meaning\n",
    "---|---\n",
    "`np.asarray()`|from list\n",
    "`np.diag()`|create matrix diagonal\n",
    "`np.zeros()`, `np.ones()`|all 0 or 1\n",
    "`np.eye()`|identity matrix\n",
    "`np.linspace(begin, end, N)`|samples domain with `N` points\n",
    "`np.arange(begin, end, step)`|creates monotonically increasing or decreasing array \n",
    "`np.random.rand()`| random values\n",
    "`np.mgrid[0:5,0:5]`|mesh grid\n",
    "`np.genfromtxt()`|from file (text)\n",
    "`np.load()`|read previously stored Numpy array from file\n",
    "\n",
    "### Other\n",
    "-------\n",
    "\n",
    "command|meaning\n",
    "---|---\n",
    "`np.pi`, `np.e`|$\\pi$, $e$\n",
    "`np.sqrt()`|square root (element wise)\n",
    "`np.sin()`, `np.cos()`,`np.tan()`|trigoniometric functions (element wise)\n",
    "`np.power(x,y)`| $x^y$\n",
    "`np.log(x)`|$\\ln(x)$\n",
    "`np.sum()`|sum all elements in array \n",
    "`np.sum(axis=)`|sum all elements in array over specified dimension(s)\n",
    "`np.min()`, `np.max()`, `np.mean()`|report min/max/mean over all elements\n",
    "`np.dot(x,y)`|dot product\n",
    "`np.transpose(x)`, `x.T`|$x^T$\n",
    "\n",
    "More commands are found in the [Numpy Reference](https://docs.scipy.org/doc/numpy/reference/index.html).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array operations\n",
    "The central datatype in Numpy is the `ndarray`. An `ndarray` can represent a both vectors and matrices (and higher order objects), depending on its dimensions or _shape_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 5 6]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.asarray([4,5,6]) # create array from list\n",
    "print(x)\n",
    "x.shape # vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The great power of Numpy arrays is the capability of doing arithmetic directly on these arrays, not their elements, similar to MATLAB. Not only makes this easier-to-read code, the performance is also greatly improved. With lists, arithmetic is only allowed on the elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8, 10, 12])"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3.1 (arrays)**\n",
    "1. Implement a function that takes as input an array `x` and returns $f(x) = x^2 + \\sin(8x)$. \n",
    "2. Test the function on the 100 `x` values sampled between $[-\\pi, \\pi]$. \n",
    "3. Make a lineplot of `f(x)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dimensions & `np.newaxis`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.zeros(10) # vector\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 10)"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.eye(10) # identity matrix\n",
    "M.shape # matrix "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the first example, `x` has only a single dimension, despite the trailing comma. When transposing the vector this is an issue, because the transposed vector will also have just a single dimension. In other words, one-dimensional ndarrays (having only ’rows’) are not readily transformed into something two-dimensional (having ’columns’ and ’rows’), although that would be desired from a mathematical point of view.\n",
    "\n",
    "In order to perform an actual transpose, x needs either two dimensions to start with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((10, 1), (1, 10))"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.zeros((10,1))\n",
    "y = x.T # transpose\n",
    "x.shape, y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or we need to \"add\" the missing dimension with `np.newaxis` before performing the transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 10)"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.zeros(10)\n",
    "y = x[:,np.newaxis].T\n",
    "y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark.** \"Axis\" is Numpy-speak for \"dimension\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3.2 (vectors)** \n",
    "1. Perform `len()` on the arrays `x` and `y` defined by \n",
    "```python\n",
    "x = np.zeros((10,1))\n",
    "y = x.T \n",
    "```\n",
    "What is the interpretation of `len()` here?\n",
    "2. Consider the code\n",
    "```python\n",
    "for r in vec: \n",
    "      print(r)\n",
    "```\n",
    "What is the interpretation of `r`? Verify your answer using first `vec = x` and then `vec = y`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selection & indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to lists, selection of single elements in an array is done through the bracket notation `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(5)\n",
    "x[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the variable is a matrix, a single element is selected by specifying both row and column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.64207677532852081"
      ]
     },
     "execution_count": 260,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.random.rand(3,3)\n",
    "M[0,1] # row 0, column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The entire row is selected when just a single dimension is specified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.5437085 ,  0.64207678,  0.74504719])"
      ]
     },
     "execution_count": 263,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[0] # first row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The colon `:` stands for _all_. So to select a single column, we specify _all rows_ of that column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.5437085 ,  0.81663738,  0.93362806])"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,0] # first column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy operations can readily be performed on such sub-matrices, which are called **slices**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.76465797798229918"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(M[:,0]) # mean value of first column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3.3 (statistics)** Two-dimensional Numpy arrays do not always represent matrices, they may also be used to store data. Results from a computer simulation for example, or field measurements. \n",
    "\n",
    "Japanese researchers take great interest in radioactive decay. The radioactivity of three different samples $(s_1, s_2, s_3)$ was tested at four different times. This yielded the following table:\n",
    "\n",
    "Activity [-] | t = 0 | t = 1 | t = 2 | t = 3\n",
    "---|---|---|---|---\n",
    "$s_1$|8.5|4.3|2.5|2.8\n",
    "$s_2$|10.1|5.9|2.3|1.1\n",
    "$s_3$|5.0|-1.0|4.6|4.4\n",
    "\n",
    "1. Define this table manually as $A_0$: `A0 = np.asarray([[8.5,4.3,3.5,2.8], [..], [..]])`\n",
    "\n",
    "2. The value -1.0 in $A_0$ represents a measurement failure. Repair this element by substituting $s_3$’s mean activity at t = 0 and t = 2. Use array indices `[]` to do this.\n",
    "\n",
    "3. The measuring device was found to have a consistent bias of 0.1. Subtract the bias from all values in $A_0$ and store the result as $A_1$.\n",
    "\n",
    "4. Determine the average activity at t = 0, using array slicing and np.mean().\n",
    "\n",
    "5. Determine the average activity for all times, using the axis argument of function `np.mean()`. Recall that ’axis’ means dimension in Numpy.\n",
    "\n",
    "6. The standard deviation is calculated using `np.std()`. At what time is the spread across samples smallest?\n",
    "\n",
    "7. Determine the sample means. Subtract the sample means from the sample measurements, and store the result as $A_2$. \n",
    "\n",
    "8. Visualise the results using \n",
    "```python\n",
    "plt.imshow(A2)\n",
    "plt.colorbar()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiplications"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Numpy, there are two different product operators:\n",
    "$$x * y$$\n",
    "$$x \\cdot y$$\n",
    "that are represented by `*` and `np.dot`, respectively. In the first, element-wise multiplication, each element of x is multiplied by each corresponding element of y. The second is the mathematical dot product."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3.4 (multiplication)**\n",
    "1. Define `I` as the 10 x 10 identity matrix (see cheatsheet above), and `x = np.arange(10)[:,np.newaxis]`.\n",
    "2. Report `I.shape` and `x.shape`.\n",
    "3. Even though the number of elements is not the same, `I*x` will succeed. Explain what happens.\n",
    "4. Report `np.dot(I,x)` and `np.dot(x,I)`. Explain the message using your knowledge of linear algebra."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous exercise, we could element-wise multiply (`*`) matrix $I$ and vector $x$ even when they did not have the same size. This is enabled through a feature of Numpy called **broadcasting**. It simply means when one array is smaller than another, Numpy will try to \"duplicate\" the smaller array in order to match the larger. In the case of $I$ and $x$, $I$ had 10 columns whereas $x$ had just one. But this array\n",
    "$$[x \\; x \\;x \\;x \\;x \\;x \\;x \\;x \\;x \\;x]$$\n",
    "also has 10 columns and can be multiplied (element-wise) by $I$. \n",
    "\n",
    "Broadcasting happens automatically and without warning. It is mostly a blessing (for example: when multiplying a matrix by a scalar) but it can also be a curse and make for nasty bugs. One general recommendation is to inspect dimensions sizes regularly (`.shape`) to make sure you are computing the right thing.\n",
    "\n",
    "**Remark.** Broadcasting is not used in `np.dot` because it would lead to ambiguities. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Soft vs. hard copies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3, -1])"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(5)\n",
    "y = x\n",
    "y[-1] = -1\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe that by changing the last element in `y` we also changed the last element in `x`. This is because `y` is a so-called **soft copy** of `x`, also known as a *pointer* or a *reference*. We say that `x` and `y` are *aliased*, which means that they are corresponding to exactly the same piece of random-access memory (RAM)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![aliased](https://raw.githubusercontent.com/lvankampenhout/NM2018-python/master/aliased.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, by changing one, we are also changing the other. Unfortunately, soft copying is the default behaviour in Numpy when doing a direct assignment (`=`) and it is good to be aware of this. The advantage of soft copying is that it is much faster than the alternative: **hard copying**, which requires that the contents of the array are copied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(4)\n",
    "y = x.copy()\n",
    "y[-1] = -1\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3.5 (soft copies)**\n",
    "Consider the following function that computes $x^2$ and erases the last element in the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [],
   "source": [
    "def squareXAndZeroLastElement(x, do_square=True):\n",
    "    # Returns x**2 with last element zeroed out.\n",
    "    if (do_square):\n",
    "        y = x**2\n",
    "    else:\n",
    "        y = x\n",
    "    y[-1] = 0\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Define a vector `x` running from 0 to 5.\n",
    "2. Execute the function with `squareXAndZeroLastElement(x)` and print the result. Verify that `x` is unchanged.\n",
    "3. The function has a second Boolean parameter `do_square` that is optional. When this parameter is set to `False` observe that the squaring is disabled. Execute `squareXAndZeroLastElement(x, do_square=False)` and print the result. What happened to your original `x`?\n",
    "4. Repair the function such that it never changes the input argument `x`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mask arrays\n",
    "In the context of Numpy, a **mask** is defined as a boolean matrix that has the same size as your data array. Masks are useful for selecting elements in an array or matrix. \n",
    "\n",
    "**Example.** In climate science, output is usually generated on a latitude-longitude grid with dimensions $N \\times M$. Some points of the grid will part of the land, and some part of the ocean. We can use a land-mask (`mask_land`) to distinguish between the two. Given a field named `precip` that represents precipitation we'd have\n",
    "\n",
    "expression|selection\n",
    "---|---\n",
    "`precip[:,:]`| all points\n",
    "`precip[mask_land]`| only land points\n",
    "`precip[~mask_land]`| only ocean points\n",
    "\n",
    "A mask can be created by one of the comparison operators `<`, `>`, `>=`, `<=` , `==`, `!=`. For instance, to select all points that have precipitation $> 100$ mm, we could say `mask_100mm = precip > 100`. \n",
    "\n",
    "Arrays may be indexed by masks. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3.6 (masking)**\n",
    "1. Create a 5 × 5 matrix `M` filled with random elements, drawn from a uniform distribution over the interval $[−1, 1)$. Use `np.random.rand()`, which draws from the interval $[0, 1)$.\n",
    "2. Create a mask `mymask`, that is equal `True` where $−0.2 < M_{i,j} \\leq 0.2$, and `False` elsewhere.\n",
    "3. Count the number of $M_{i,j}$ where $−0.2 < M_{i,j} \\leq 0.2$ using `np.sum()`. Check by hand.\n",
    "4. Create a new matrix `P = np.zeros(M.shape)`. Now set $P_{i,j} = M_{i,j}$ where $M_{i,j} > 0$ using a mask.\n",
    "5. Create a function `blankSubzeroValues()`, that takes a matrix as an input. The function then sets any values that < 0 to zero and returns the result. Test by comparing `Q = blankSubzeroValues(M)` to `P`.\n",
    "6. Extend this function as follows. Use `print()` to report the message:\n",
    "     `X values have been blanked`\n",
    "where `X` is of course the actual number of entries that have been set to zero. Only report this message if 2 or more values have been blanked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional selection\n",
    "Conditional selection builds on the idea of masking, and in many cases makes for shorter and better-to-read code. The command that is used is \n",
    "\n",
    "```python\n",
    "Z = np.where(cond, X, Y)\n",
    "```\n",
    "\n",
    "with `cond` a condition or Boolean matrix. On all points where the condition evaluates to `True`, $X_{i,j}$ is returned, and $Y_{i,j}$ otherwise. In mathematical notation this can be stated as\n",
    "$$ Z_{i,j} = \n",
    "\\begin{cases}\n",
    "X_{i,j} \\qquad &\\mathrm{if} \\quad \\mathrm{cond}_{i,j} \\\\\n",
    "Y_{i,j} \\qquad &\\mathrm{if} \\quad \\mathrm{not} \\, \\mathrm{cond}_{i,j}\n",
    "\\end{cases}$$\n",
    "Note that because of Numpy broadcasting, X and Y need not be full arrays, they can also be scalars or vectors with \"equivalent\" shapes. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3.7 (where)** \n",
    "1. In the previous exercise we needed two statements to create $P$ that  $P_{i,j} = M_{i,j}$ where $M_{i,j} > 0$ and zero otherwise. Redefine $P$ using `np.where` in a single statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figures & axes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting library Matplotlib is built around two main concepts: *figures* and *axes*. A figure is the canvas or the white sheet onto which everything is drawn, including non-data related stuff like colorbars or legends. On the other hand, the axes is just the area in which the data is drawn, i.e. the xy-space. \n",
    "\n",
    "**Remark.** This means that the Matplotlib usage of ’axes’ differs from the Numpy ’axis’, which was equivalent to ’dimension’. Confusingly, Matplotlib also knows a concept of ’axis’, which are the x-axis and y-axis. Luckily, these are only rarily needed.\n",
    "\n",
    "Generally there exist two different ways of plotting: \n",
    "* with objects\n",
    "* interactively (state machine like MATLAB, `matplotlib.pyplot`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11c1e2940>]"
      ]
     },
     "execution_count": 321,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n7+uvAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11c128240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting with objects\n",
    "fig = plt.figure()         # create new figure\n",
    "ax = fig.add_subplot(111) # create new axes inside figure; 1 row, 1 column\n",
    "ax.plot(np.arange(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example just one axes object exists in the canvas (figure), named `ax`. Now the following lines of code to create the same plot using the state machine interface (pyplot):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11bd0b160>]"
      ]
     },
     "execution_count": 307,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n7+uvAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11bb53550>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting interactively\n",
    "plt.plot(np.arange(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Awesome, we only need 1 line of code, instead of three. For now, we recommend that you use this interactive interface, because its simpler to use. Using `pyplot` means that all plotting command starts with `plt.xx`. Just remember that this way of plotting is less flexible, because the axes are not named and cannot be re-used or modified by functions. To learn more about the anatomy of a figure, and the different styles of plotting, see the [Matplotlib FAQ](matplotlib.org/faq/usage_faq.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3.8 (lineplots)** Lineplots or $xy$−plots are the most simple kind of plot. First, the domain $[0,2\\pi]$ is \"discretized\" or divided into segments. We’ll start off with a rather coarse discretization:\n",
    "$$x = [0, 0.5, 1, 1.5, 2] \\pi$$\n",
    "1. Create an ndarray named x containing these values.\n",
    "2. Calculate $y_1 = sin(x)$ and plot the result using `plt.plot(x,y1,’-s’)`. Explain whether you are happy with the discretization.\n",
    "\n",
    "    The squares in the figure you just produced are called _vertices_. Mathematically speaking, the vertices are a discrete set ${x_0,x_1,...,x_N}$ at which the function $y$ is evaluated. The `s` in the plotting command stands for ’square’ which is the marker type drawn at every vertex. The `-` stands for ’solid line’ which connects the vertices using straight line segments.  \n",
    "    \n",
    "3. Increasing the resolution of x (the spacing of vertices) can be done by hand, which is cumbersome and prone to errors. Instead, use a list comprehension to generate the vertices, ideally converting them into an ndarray afterwards. Alternatively, use `np.linspace()`. Discretize the same domain, but now with 10 vertices (`np.size(x) = 10`) and remake the sine-plot. Verify that there are 9 segments in the graph. Why 9?\n",
    "4. Remake the plot with 100 vertices. Drop the ’s’ in the plot command to get rid of the markers. How many line segments are there now?\n",
    "5. In the same plot, draw $y_2 = cos(x)$. Then make the following additions:\n",
    "    * put axis labels\n",
    "    * change line thicknesses to 2.0\n",
    "    * add function descriptions as text annotations, each in their respective color\n",
    "    * change the ticks on the x-axis such that it has ticklabels $0$, $\\pi$, and $2\\pi$, at the correct positions   \n",
    "    \n",
    "  Using this [J.R. Johanssons notebook](http://nbviewer.jupyter.org/github/jrjohansson/scientific-python-lectures/blob/master/Lecture-4-Matplotlib.ipynb) as a reference  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Subplots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More elaborate plots usually requires you to switch to the object interface. For example, when you want to create multiple axes in one figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJgx8SWrCwJekJv4PcgCmcLyIQvoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11e3b3198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()         # create new figure\n",
    "ax1 = fig.add_subplot(121) # create new axes inside figure; 1 row, 2 columns\n",
    "ax2 = fig.add_subplot(122) # create new axes inside figure; 1 row, 2 columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 4 - miscellaneous "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "External modules or libraries are imported with the `import` statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will import the library functions as `numpy.sin`, `numpy.cos`, ... To save space, it is the convention to rename the library to `np` using the `as` keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One could even save more space by importing the library contents without any prefix (`sin`, `cos`, ...) using the wildcard operator (`*`) yet this is **highly discouraged** because A) it obfuscates the origin of functions and B) will likely lead to _variable name clashes_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import * # not recommended"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you don't need the full library but just one or two functions. In that case you could use `from` in combination with the specific function names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import sqrt # this is OK, since it allows insight into the origin of sqrt()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}