numpy-batch20.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy == numeric Python\n",
    "\n",
    "www.numpy.org\n",
    "\n",
    "ndarray = represents an N-dimensional array (== tensor)\n",
    "\n",
    "* N==0 scalar\n",
    "* N==1 vector\n",
    "* N==2 matrix\n",
    "* N== ....\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Whetting your appetite\n",
    "Numpy makes calculations **really fast**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26.9 ms ± 5.51 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "313 µs ± 82.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "n = 10_000\n",
    "# sum of squares of 0, 1, 2, ..., n-1\n",
    "%timeit sum([i**2 for i in range(n)])\n",
    "%timeit ( np.arange(n)**2 ).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def variance(x):\n",
    "    n = len(x)\n",
    "    mean = sum(x) / n\n",
    "    \n",
    "    sum_sq = 0\n",
    "    for i in range(n):\n",
    "        sum_sq += (x[i]-mean)**2\n",
    "    \n",
    "    return sum_sq/(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 1.6666666666666667)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variance([0, 0, 0, 0, 0]), variance([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(123)\n",
    "x = np.random.rand(10_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "85.9 ms ± 8.07 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "486 µs ± 97.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "479 µs ± 69.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit variance(x)\n",
    "%timeit x.var(ddof=1)\n",
    "%timeit ((x - x.mean())**2).sum()/(len(x) - 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Loading Arrays\n",
    "\n",
    "- `np.load(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII')`\n",
    "- `np.loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[0.86077448 0.59449515 0.2448484  0.36079936 0.34046729 0.48255381\n",
      " 0.72563607 0.43003229 0.15350375 0.24524989 0.92316945 0.86258945\n",
      " 0.8456167  0.0601834  0.03900676]\n"
     ]
    }
   ],
   "source": [
    "a = np.loadtxt('data/a.txt')\n",
    "print(type(a))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[0.86077448 0.59449515 0.2448484  0.36079936 0.34046729 0.48255381\n",
      " 0.72563607 0.43003229 0.15350375 0.24524989 0.92316945 0.86258945\n",
      " 0.8456167  0.0601834  0.03900676]\n"
     ]
    }
   ],
   "source": [
    "a = np.load('data/a.npy')\n",
    "print(type(a))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.lib.npyio.NpzFile'>\n",
      "['arr_0', 'arr_1']\n"
     ]
    }
   ],
   "source": [
    "arrays = np.load('data/a.npz')\n",
    "print(type(arrays))\n",
    "print(arrays.files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[0.86077448 0.59449515 0.2448484  0.36079936 0.34046729 0.48255381\n",
      " 0.72563607 0.43003229 0.15350375 0.24524989 0.92316945 0.86258945\n",
      " 0.8456167  0.0601834  0.03900676]\n",
      "<class 'numpy.ndarray'>\n",
      "[0.17583129 0.33737294 0.62612302 0.20691698 0.88523754 0.52178992\n",
      " 0.76665624 0.70404154 0.82148591 0.88617062]\n"
     ]
    }
   ],
   "source": [
    "a = arrays['arr_0']\n",
    "b = arrays['arr_1']\n",
    "print(type(a))\n",
    "print(a)\n",
    "print(type(b))\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Saving Arrays\n",
    "\n",
    "- `np.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='n', header='', footer='', comments='# ', encoding=None)`\n",
    "- `np.savez(file, *args, **kwds)`\n",
    "- `np.save(file, arr, allow_pickle=True, fix_imports=True)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('data/new_a.txt', a)\n",
    "np.save('data/new_a.npy', a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['arr_0', 'arr_1']\n"
     ]
    }
   ],
   "source": [
    "np.savez('data/new_a.npz', a, b)\n",
    "check = np.load('data/new_a.npz')\n",
    "print(check.files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['my_a_array', 'some_weird_name']\n",
      "[0.17583129 0.33737294 0.62612302 0.20691698 0.88523754 0.52178992\n",
      " 0.76665624 0.70404154 0.82148591 0.88617062]\n"
     ]
    }
   ],
   "source": [
    "np.savez('data/new_a.npz', my_a_array=a, some_weird_name=b)\n",
    "check = np.load('data/new_a.npz')\n",
    "print(check.files)\n",
    "print(check['some_weird_name'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Creating Arrays\n",
    "A numpy array is similar to a Python list but contains only data of the same type. E.g. only floats, or only dictionaries. Python lists on the other hand allow for different types in the same list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## from built-in functions\n",
    "\n",
    "- `np.arange([start, ]stop, [step, ]dtype=None)`\n",
    "- `np.zeros(shape, dtype=float, order='C')`\n",
    "- `np.ones(shape, dtype=float, order='C')`\n",
    "- `np.empty(shape, dtype=float, order='C')`\n",
    "- `np.full(shape, fillvalue, dtype=float, order='C')`\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*np.arange* is similar to *range* for lists.  \n",
    "With only __one argument__ *N* an array is created from 0 to the *N - 1*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With __two arguments__ *N* and *M* an array is created that starts with *N* and ends with *M - 1*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(2, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With __three arguments__ *N*, *M*, and *L* an array is created that starts *N*, ends with *M - 1* and takes steps of size *L* in between."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 5, 7, 9])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3, 11, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With __dtype__ the type of stored data can be specified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10, dtype=np.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1.])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.5932131e-316, 0.0000000e+000, 0.0000000e+000, 0.0000000e+000,\n",
       "       2.3715151e-322])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9.3, 9.3, 9.3])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full(3, 9.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## from lists\n",
    "\n",
    "- `np.array(list)`\n",
    "    \n",
    "If not all elements in the list have the same type numpy automatically converts the data to a common type, if possible. If not it will be an 'object' type.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   4,   2, 290])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [1, 4, 2, 290]\n",
    "np.array(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use integers and a string in the list. This is converted to all strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1', '4', 'a', '290'], dtype='<U21')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [1, 4, 'a', 290]\n",
    "np.array(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we use an integer, a string and a dictionary. This is all converted to dtype object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 'a', {'b': 4}], dtype=object)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [1, 'a', {'b':4}]\n",
    "np.array(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## from other arrays\n",
    "\n",
    "- `np.empty_like(a, dtype=None, order='K', subok=True, shape=None)`\n",
    "- `np.full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)`\n",
    "- `np.zeros_like(a, dtype=None, order='K', subok=True, shape=None)`\n",
    "- `np.ones_like(a, dtype=None, order='K', subok=True, shape=None)`\n",
    "    \n",
    "order is a memory layout keyword and subok is a keyword specifying the (sub)-class. I haven't used either one.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([                  0, 8462656716707034229, 7311068618034541413,\n",
       "       2466321603649696626, 7017771692297694773, 3544388029326189940,\n",
       "       6068092717742697785, 4049644503005016113, 6500154650853258542,\n",
       "           140435332824354])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "np.empty_like(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full_like(x, 0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full_like(x, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full_like(x, 0.3, dtype=np.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros_like(x, shape=(3, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Array properties and methods\n",
    "\n",
    "- Properties\n",
    "    - ndim\n",
    "    - shape\n",
    "    - size\n",
    "    - T\n",
    "    ...\n",
    "- Methods\n",
    "    - max\n",
    "    - min\n",
    "    - mean\n",
    "    - reshape\n",
    "    - sort\n",
    "    - flatten\n",
    "    - tolist\n",
    "    - swapaxes ...\n",
    "    \n",
    "There are many more properties and methods that you can look up in the documentation.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ndim =  1\n",
      "shape =  (12,)\n",
      "size =  12\n",
      "[  3.     6.     0.     9.2    0.55  12.     4.3    6.   100.   -23.\n",
      "  -4.33   0.  ]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([3, 6, 0, 9.2 , 0.55, 12, 4.3, 6, 100, -23, -4.33, 0])\n",
    "print('ndim = ', x.ndim)\n",
    "print('shape = ', x.shape)\n",
    "print('size = ', x.size)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max =  100.0\n",
      "min = -23.0\n",
      "mean =  9.476666666666668\n"
     ]
    }
   ],
   "source": [
    "print('max = ', x.max())\n",
    "print('min =', x.min())\n",
    "print('mean = ', x.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ndim =  2\n",
      "shape =  (2, 6)\n",
      "size =  12\n",
      "[[  3.     6.     0.     9.2    0.55  12.  ]\n",
      " [  4.3    6.   100.   -23.    -4.33   0.  ]]\n",
      "[[  3.     6.     0.   -23.    -4.33   0.  ]\n",
      " [  4.3    6.   100.     9.2    0.55  12.  ]]\n",
      "[[-23.    -4.33   0.     0.     3.     6.  ]\n",
      " [  0.55   4.3    6.     9.2   12.   100.  ]]\n"
     ]
    }
   ],
   "source": [
    "x = x.reshape((2, 6))\n",
    "print('ndim = ', x.ndim)\n",
    "print('shape = ', x.shape)\n",
    "print('size = ', x.size)\n",
    "print(x)\n",
    "x.sort(axis=0)\n",
    "print(x)\n",
    "x.sort(axis=1)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note_\n",
    "\n",
    "- Sort changes the array that it works on.\n",
    "- Reshape does __not__ change the array it works on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Like always in Python we can string methods together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-23.0, -4.33, 0.0, 0.0, 3.0, 6.0], [0.55, 4.3, 6.0, 9.2, 12.0, 100.0]]\n",
      "[-23.0, -4.33, 0.0, 0.0, 3.0, 6.0, 0.55, 4.3, 6.0, 9.2, 12.0, 100.0]\n"
     ]
    }
   ],
   "source": [
    "print(x.tolist())\n",
    "print(x.flatten().tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here comes x\n",
      "[[-23.    -4.33   0.     0.     3.     6.  ]\n",
      " [  0.55   4.3    6.     9.2   12.   100.  ]]\n",
      "here comes x.reshape(6, 2)\n",
      "[[-23.    -4.33]\n",
      " [  0.     0.  ]\n",
      " [  3.     6.  ]\n",
      " [  0.55   4.3 ]\n",
      " [  6.     9.2 ]\n",
      " [ 12.   100.  ]]\n",
      "here comes x.swapaxes(0, 1)\n",
      "[[-23.     0.55]\n",
      " [ -4.33   4.3 ]\n",
      " [  0.     6.  ]\n",
      " [  0.     9.2 ]\n",
      " [  3.    12.  ]\n",
      " [  6.   100.  ]]\n",
      "here comes x.T\n",
      "[[-23.     0.55]\n",
      " [ -4.33   4.3 ]\n",
      " [  0.     6.  ]\n",
      " [  0.     9.2 ]\n",
      " [  3.    12.  ]\n",
      " [  6.   100.  ]]\n"
     ]
    }
   ],
   "source": [
    "print(\"here comes x\")\n",
    "print(x)\n",
    "print(\"here comes x.reshape(6, 2)\")\n",
    "print(x.reshape(6, 2))\n",
    "print(\"here comes x.swapaxes(0, 1)\")\n",
    "print(x.swapaxes(0, 1))\n",
    "print(\"here comes x.T\")\n",
    "print(x.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note*: reshape and swapaxes are not identical! Swapaxes is identical to transpose (T) if we have an array with two axes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 1. Exercise\n",
    "\n",
    "You are working for a company that monitors the weather in Berlin. The company has collected data on temperature at one specific location.\n",
    "The data is stored in the file 'data.npz'. Each array in the file represents one day.\n",
    "1. Create __one__ array that holds all temperatures of all days such that the data of one day is in one column.\n",
    "2. Create __one__ array that holds all temperatures of all days such that the data of one day is in one row.\n",
    "3. Print out __neatly__\n",
    "    - The minimum and maximum temperature for each day.\n",
    "    - The mean temperature for each day.\n",
    "    - The minimum, maximum and mean temperature for all three days.\n",
    "4. Order the temperatures of each day and generate a list of the highest temperature and one with the lowest temperature of each day.\n",
    "5. Save the results of 4 into __one__ file and give the arrays the names 'maximum' and 'minimum' in the file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slicing and Dicing\n",
    "\n",
    "Just like with lists elements of numpy arrays can be addressed individually or collectively.\n",
    "- the index of the element is given in brackets\n",
    "- the indexes are given as slices\n",
    "- the indexes are given as an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n",
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]\n",
      " [15 16 17 18 19]]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(20)\n",
    "print(x)\n",
    "y = np.arange(20).reshape(4,5)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple index works just like with lists. For arrays the indexes are separated by a comma. The first index refers to the row and the second refers to the column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18 10\n",
      "18 10\n"
     ]
    }
   ],
   "source": [
    "print(x[-2], x[10])\n",
    "print(y[-1,-2], y[2,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slices work like `[start:stop[:step]]` where start and stop are mandatory and step is optional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "[[ 7  9]\n",
      " [12 14]]\n"
     ]
    }
   ],
   "source": [
    "print(x[1:5])\n",
    "print(y[1:3, 2:5:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slices can also be used to reverse the order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12 10  8  6]\n",
      "[17  7]\n"
     ]
    }
   ],
   "source": [
    "print(x[12:4: -2])\n",
    "print(y[::-2, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use index arrays with integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4  8  5 17 10]\n",
      "[17 11]\n"
     ]
    }
   ],
   "source": [
    "idx1 = np.array([4, 8, 5, -3, 10])\n",
    "idx2 = np.array([-1, 2])\n",
    "idx3 = np.array([2, 1])\n",
    "print(x[idx1])\n",
    "print(y[idx2, idx3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we use an index array with booleans. A combination of booleans, slices and integers is also possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  3  7  9 10 11 14 15 19]\n",
      "[10 17]\n"
     ]
    }
   ],
   "source": [
    "T = True\n",
    "F = False\n",
    "idx1 = np.array([F, F, T, T, F, F, F, T, F, T, T, T, F, F, T, T, F, F, F, T])\n",
    "idx2 = np.array([F, F, T, T])\n",
    "idx3 = np.array([0, 2])\n",
    "print(x[idx1])\n",
    "print(y[idx2, idx3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also get rows or columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15 16 17 18 19]\n",
      "[10 11 12 13 14]\n",
      "[ 0  5 10 15]\n"
     ]
    }
   ],
   "source": [
    "print(y[3])  # the fourth row\n",
    "print(y[2, :])  # the third row\n",
    "print(y[:, 0])  # the first column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparison and Arithmetic\n",
    "\n",
    "The comparison or the arithmetic on arrays is done elementwise. Here are some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  2  4  6  8 10 12 14 16 18]\n",
      "[0.         0.33333333 0.66666667 1.         1.33333333 1.66666667\n",
      " 2.         2.33333333 2.66666667 3.        ]\n",
      "[False False False False False False False False False False]\n",
      "[ True  True  True  True  True  True  True  True  True  True]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "y = np.arange(10)\n",
    "print(x + y)\n",
    "print(x / 3)\n",
    "print(x > y)\n",
    "print(x == y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "[False False False  True  True  True  True  True  True  True]\n",
      "[ True  True  True  True  True False False False False False]\n"
     ]
    }
   ],
   "source": [
    "print(2 < 3 < 5)\n",
    "print(2 < x)\n",
    "print(x < 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "that did not work\n",
      "that did not work again\n",
      "[False False False  True  True False False False False False]\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(2 < x < 5)\n",
    "except:\n",
    "    print('that did not work')\n",
    "try:\n",
    "    print(2 < x & x < 5)\n",
    "except:\n",
    "    print('that did not work again')\n",
    "try:\n",
    "    print((2 < x) & (x < 5))\n",
    "except:\n",
    "    print('AGAIN ????')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "that did not work\n",
      "that did not work again\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print((2 < x < 5).any())\n",
    "except:\n",
    "    print('that did not work')\n",
    "try:\n",
    "    print((2 < x & x < 5)).all()\n",
    "except:\n",
    "    print('that did not work again')\n",
    "try:\n",
    "    print((2 < x).any() & (x < 5).all())\n",
    "except:\n",
    "    print('AGAIN ????')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Broadcasting\n",
    "In general, arrays must have identical shapes for arithmetic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no that doesn't work\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    np.arange(10) * np.arange(5)\n",
    "except:\n",
    "    print(\"no that doesn't work\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, there is something called broadcasting. Broadcasting is very powerful but maybe not immediatly intuitive. Let's start with a very simple example. Multiplication of a scalar with an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x and x * 2\n",
      "[0 1 2 3 4 5 6 7]\n",
      "[ 0  2  4  6  8 10 12 14]\n",
      "\n",
      "y and y * 3\n",
      "[[0 1 2 3]\n",
      " [4 5 6 7]]\n",
      "[[ 0  3  6  9]\n",
      " [12 15 18 21]]\n",
      "\n",
      "z and z * 4\n",
      "[[0 1]\n",
      " [2 3]\n",
      " [4 5]\n",
      " [6 7]]\n",
      "[[ 0  4]\n",
      " [ 8 12]\n",
      " [16 20]\n",
      " [24 28]]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(8)\n",
    "y = np.arange(8).reshape(2, 4)\n",
    "z = np.arange(8).reshape(4, 2)\n",
    "print(\"x and x * 2\")\n",
    "print(x)\n",
    "print(x * 2)\n",
    "print(\"\\ny and y * 3\")\n",
    "print(y)\n",
    "print(y * 3)\n",
    "print(\"\\nz and z * 4\")\n",
    "print(z)\n",
    "print(z * 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try to multiply these arrays with the vector np.array([2, 3]) and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a and a.shape [2 3] (2,)\n",
      "\n",
      "x * a:\n",
      "x * a does not work\n",
      "\n",
      "y * a:\n",
      "y * a does not work\n",
      "\n",
      "z * a:\n",
      "[[ 0  3]\n",
      " [ 4  9]\n",
      " [ 8 15]\n",
      " [12 21]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([2,3])\n",
    "print(\"a and a.shape\", a, a.shape)\n",
    "print(\"\\nx * a:\")\n",
    "try:\n",
    "    print(x * a)\n",
    "except:\n",
    "    print('x * a does not work')\n",
    "print(\"\\ny * a:\")\n",
    "try:\n",
    "    print(y * a)\n",
    "except:\n",
    "    print('y * a does not work')\n",
    "print(\"\\nz * a:\")\n",
    "try:\n",
    "    print(z * a)\n",
    "except:\n",
    "    print('z * a does not work')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now let's reshape the vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a and a.shape [[2]\n",
      " [3]] (2, 1)\n",
      "\n",
      "x * a:\n",
      "[[ 0  2  4  6  8 10 12 14]\n",
      " [ 0  3  6  9 12 15 18 21]]\n",
      "\n",
      "y * a:\n",
      "[[ 0  2  4  6]\n",
      " [12 15 18 21]]\n",
      "\n",
      "z * a:\n",
      "z * a does not work\n"
     ]
    }
   ],
   "source": [
    "a = np.array([2,3]).reshape(2,1)\n",
    "print(\"a and a.shape\", a, a.shape)\n",
    "print(\"\\nx * a:\")\n",
    "try:\n",
    "    print(x * a)\n",
    "except:\n",
    "    print('x * a does not work')\n",
    "print(\"\\ny * a:\")\n",
    "try:\n",
    "    print(y * a)\n",
    "except:\n",
    "    print('y * a does not work')\n",
    "print(\"\\nz * a:\")\n",
    "try:\n",
    "    print(z * a)\n",
    "except:\n",
    "    print('z * a does not work')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Exercise\n",
    "\n",
    "Use the data from the previous exercise.\n",
    "\n",
    "- Print out __neatly__ the temperatures at 3pm on Monday, 10am on Tuesday and 6pm on Wednesday.\n",
    "- Print out the temperatures at 2pm and at 10am of each day and in that order.\n",
    "- Print out the temperatures of every third hour starting at 10pm and ending at 9am on Wednesday.\n",
    "- Print out all temperatures that are below 18.\n",
    "- The temperatures are in Celsius. Convert them to Farenheit (°F = °C × 1.8 + 32)\n",
    "- And just for the sake of practicing divide the temparatures of Monday by 2, of Tuesday by 3 and of Wednesday by 4."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Useful Functions\n",
    "\n",
    "- mathematical functions like `np.sin`, `np.exp`, `np.log` ... [numpy doc](<https://docs.scipy.org/doc/numpy/reference/routines.math.html>)\n",
    "- linear algebra like eigenvectors and -values, inverse and norm ... [scipy doc](<https://docs.scipy.org/doc/numpy/reference/routines.linalg.html>)\n",
    "- matrix and vector multiplication\n",
    "- logical functions like `np.where`, `np.argwhere`, `np.nonzero`\n",
    "- random numbers like `np.random.randn`, `np.random.randint`, `np.random.choice` ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here comes x:  [0 1 2]\n",
      "here comes y:  [3 4 5]\n",
      "here comes z: \n",
      "[[ 6  7  8]\n",
      " [ 9 10 11]\n",
      " [12 13 14]]\n",
      "here comes the sin of x:  [0.         0.84147098 0.90929743]\n",
      "here comes the log of x + 1:  [0.         0.69314718 1.09861229]\n",
      "here comes the norm of x:  2.23606797749979\n"
     ]
    }
   ],
   "source": [
    "from scipy import linalg\n",
    "x = np.arange(3)\n",
    "y = np.arange(3,6)\n",
    "z = np.arange(6, 15).reshape(3,3)\n",
    "print('here comes x: ', x)\n",
    "print('here comes y: ', y)\n",
    "print('here comes z: ')\n",
    "print(z)\n",
    "print('here comes the sin of x: ', np.sin(x))\n",
    "print('here comes the log of x + 1: ', np.log(x + 1))\n",
    "print('here comes the norm of x: ', linalg.norm(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here comes the identity matrix: \n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n",
      "here comes the product of x and y:  14\n",
      "here comes the product of x and z:  [33 36 39]\n",
      "here comes the product of x, z, and y:  438\n",
      "here comes the product of z and z: \n",
      "[[195 216 237]\n",
      " [276 306 336]\n",
      " [357 396 435]]\n"
     ]
    }
   ],
   "source": [
    "print('here comes the identity matrix: ')\n",
    "print(np.eye(3))\n",
    "print('here comes the product of x and y: ', x @ y)\n",
    "print('here comes the product of x and z: ', x @ z)\n",
    "print('here comes the product of x, z, and y: ', x @ z @ y)\n",
    "print('here comes the product of z and z: ')\n",
    "print(z @ z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([1, 2, 2, 2]), array([2, 0, 1, 2]))\n",
      "[[1 2]\n",
      " [2 0]\n",
      " [2 1]\n",
      " [2 2]]\n",
      "[[ 60  70  80]\n",
      " [ 90 100  11]\n",
      " [ 12  13  14]]\n"
     ]
    }
   ],
   "source": [
    "print(np.where(z > 10))\n",
    "print(np.argwhere(z > 10))\n",
    "print(np.where(z > 10, z, 10 * z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([0, 0, 0, 1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2, 0, 1, 2]))\n",
      "[0 1 2 3 4 5 6 7 8]\n"
     ]
    }
   ],
   "source": [
    "print(np.nonzero(z))\n",
    "print(np.flatnonzero(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.random.choice(x) chooses a random element in x:  1\n",
      "np.random.randint(5) chooses a random integer from 0 to 4:  2\n",
      "np.random.randint(5, 16) chooses a random integer from 5 to 15:  15\n",
      "np.random.randn() chooses a random float from a normal distribution:  0.3771137178539186\n",
      "np.random.randn(2, 3, 4) chooses random floats in an array from a normal distribution: \n",
      "[[[-0.9915795  -0.94367527  1.60898888  0.31828661]\n",
      "  [ 0.05893849  0.38069425  0.54869711 -0.50130167]\n",
      "  [-1.41609521  1.25577497  0.25417228  0.83392561]]\n",
      "\n",
      " [[-0.91920306  0.34203327 -1.93782253 -0.80602036]\n",
      "  [-0.16721394 -0.09519763  1.30942981 -1.44199699]\n",
      "  [-0.11725418  0.26042864  1.02241203 -1.77891872]]]\n"
     ]
    }
   ],
   "source": [
    "print('np.random.choice(x) chooses a random element in x: ', np.random.choice(x))\n",
    "print('np.random.randint(5) chooses a random integer from 0 to 4: ', np.random.randint(5))\n",
    "print('np.random.randint(5, 16) chooses a random integer from 5 to 15: ', np.random.randint(5, 16))\n",
    "print('np.random.randn() chooses a random float from a normal distribution: ', np.random.randn())\n",
    "print('np.random.randn(2, 3, 4) chooses random floats in an array from a normal distribution: ')\n",
    "print(np.random.randn(2, 3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Axes and Dimensions\n",
    "\n",
    "- 1 axis -> vector\n",
    "- 2 axes -> matrix\n",
    "- 3+ axes -> tensor\n",
    "\n",
    "along each axis we call the number of entries the dimension\n",
    "\n",
    "- a vector with 10 entries is 10-dimensional\n",
    "- a matrix with dimension 2 and 3 has two rows and three columns\n",
    "- similar for tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shapes and values of a, b, c, and d\n",
      "\n",
      "here comes a:  (1, 2, 3)\n",
      "[[[1. 1. 1.]\n",
      "  [1. 1. 1.]]]\n",
      "\n",
      "here comes b:  (2, 3, 1)\n",
      "[[[1.]\n",
      "  [1.]\n",
      "  [1.]]\n",
      "\n",
      " [[1.]\n",
      "  [1.]\n",
      "  [1.]]]\n",
      "\n",
      "here comes c:  (3, 1, 2)\n",
      "[[[1. 1.]]\n",
      "\n",
      " [[1. 1.]]\n",
      "\n",
      " [[1. 1.]]]\n",
      "\n",
      "here comes d:  (3,)\n",
      "[4 5 6]\n"
     ]
    }
   ],
   "source": [
    "a = np.ones((1,2,3))\n",
    "b = np.ones((2,3,1))\n",
    "c = np.ones((3,1,2))\n",
    "d = np.arange(4, 7)\n",
    "print(\"shapes and values of a, b, c, and d\")\n",
    "print(\"\\nhere comes a: \", a.shape)\n",
    "print(a)\n",
    "print(\"\\nhere comes b: \", b.shape)\n",
    "print(b)\n",
    "print(\"\\nhere comes c: \", c.shape)\n",
    "print(c)\n",
    "print(\"\\nhere comes d: \", d.shape)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note the difference between b and c! How many axes does every array have and what are the dimensions?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix Multiplication\n",
    "\n",
    "Given two vectors/matrices/tensors __A__ and __B__ we define a matrix multiplication also called __dot product__ as\n",
    "\n",
    "$$ A \\cdot B = \\sum_i^n A_i \\cdot B_i $$\n",
    "\n",
    "Note that this is different from an elementwise multiplication of vectors/matrices/tensors.\n",
    "\n",
    "$$ A \\star B = A_i \\cdot B_i $$\n",
    "\n",
    "In the cells below there are a variety of different multiplications, both matrix and elementwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a * d:  (1, 2, 3)\n",
      "d * a:  (1, 2, 3)\n",
      "b * d:  (2, 3, 3)\n",
      "d * b:  (2, 3, 3)\n",
      "c * d doesn't work\n",
      "d * c doesn't work\n"
     ]
    }
   ],
   "source": [
    "# broad casting\n",
    "print(\"a * d: \", (a * d).shape)\n",
    "print(\"d * a: \", (d * a).shape)\n",
    "print(\"b * d: \", (b * d).shape)\n",
    "print(\"d * b: \", (d * b).shape)\n",
    "try:\n",
    "    print(\"c * d: \", (c * d).shape)\n",
    "except:\n",
    "    print(\"c * d doesn't work\")\n",
    "try:\n",
    "    print(\"d * c: \", (d * c).shape)\n",
    "except:\n",
    "    print(\"d * c doesn't work\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape a:  (1, 2, 3)\n",
      "shape b:  (2, 3, 1)\n",
      "shape c:  (3, 1, 2)\n",
      "shape d:  (3,)\n",
      "\n",
      "a dot d:\n",
      "(1, 2)\n",
      "[[15. 15.]]\n",
      "\n",
      "d dot a:\n",
      "d dot a doesn't work!\n",
      "\n",
      "a dot b:\n",
      "b dot d doesn't work!\n",
      "\n",
      "d dot b:\n",
      "(2, 1)\n",
      "[[15.]\n",
      " [15.]]\n",
      "\n",
      "c dot d:\n",
      "c dot d doesn't work!\n",
      "\n",
      "d dot c:\n",
      "d dot c doesn't work!\n",
      "\n",
      "a dot b:\n",
      "(1, 2, 2, 1)\n",
      "[[[[3.]\n",
      "   [3.]]\n",
      "\n",
      "  [[3.]\n",
      "   [3.]]]]\n",
      "\n",
      "b dot a:\n",
      "b dot a doesn't work!\n",
      "\n",
      "a dot c:\n",
      "a dot c doesn't work!\n",
      "\n",
      "c dot a:\n",
      "(3, 1, 1, 3)\n",
      "[[[[2. 2. 2.]]]\n",
      "\n",
      "\n",
      " [[[2. 2. 2.]]]\n",
      "\n",
      "\n",
      " [[[2. 2. 2.]]]]\n",
      "\n",
      "b dot c:\n",
      "(2, 3, 3, 2)\n",
      "\n",
      "c dot b:\n",
      "c dot b doesn't work!\n"
     ]
    }
   ],
   "source": [
    "print('shape a: ', a.shape)\n",
    "print('shape b: ', b.shape)\n",
    "print('shape c: ', c.shape)\n",
    "print('shape d: ', d.shape)\n",
    "print('\\na dot d:')\n",
    "try:\n",
    "    x = np.dot(a, d)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"a dot d doesn't work!\")\n",
    "print('\\nd dot a:')\n",
    "try:\n",
    "    x = np.dot(d, a)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"d dot a doesn't work!\")\n",
    "print('\\na dot b:')\n",
    "try:\n",
    "    x = np.dot(b, d)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"b dot d doesn't work!\")\n",
    "print('\\nd dot b:')\n",
    "try:\n",
    "    x = np.dot(d, b)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"d dot b doesn't work!\")\n",
    "print('\\nc dot d:')\n",
    "try:\n",
    "    x = np.dot(c, d)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"c dot d doesn't work!\")\n",
    "print('\\nd dot c:')\n",
    "try:\n",
    "    x = np.dot(d, c)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"d dot c doesn't work!\")\n",
    "print('\\na dot b:')\n",
    "try:\n",
    "    x = np.dot(a, b)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"a dot b doesn't work!\")\n",
    "print('\\nb dot a:')\n",
    "try:\n",
    "    x = np.dot(b, a)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"b dot a doesn't work!\")\n",
    "print('\\na dot c:')\n",
    "try:\n",
    "    x = np.dot(a, c)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"a dot c doesn't work!\")\n",
    "print('\\nc dot a:')\n",
    "try:\n",
    "    x = np.dot(c, a)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"c dot a doesn't work!\")\n",
    "print('\\nb dot c:')\n",
    "try:\n",
    "    x = np.dot(b, c)\n",
    "    print(x.shape)\n",
    "#    print(x)\n",
    "except:\n",
    "    print(\"b dot c doesn't work!\")\n",
    "print('\\nc dot b:')\n",
    "try:\n",
    "    x = np.dot(c, b)\n",
    "    print(x.shape)\n",
    "    print(x)\n",
    "except:\n",
    "    print(\"c dot b doesn't work!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Exercise\n",
    "\n",
    "Check the results of the previous cell. Formulate for yourself a small paragraph (three to five sentences) that summarizes your findings. Try to use the words dimension and axis/axes as well as broadcasting and matrix multiplication."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensor Product\n",
    "There is a generalization of products to tensors. This is implemented in numpy's tensordot function.\n",
    "\n",
    "`numpy.tensordot(a, b, axes=N)`\n",
    "\n",
    "The argument 'axes' indicates over how many axes the summation runs. This affects the N last axes of tensor a and the first N axes of tensor b.\n",
    "\n",
    "The special case of N = 0 is called the outer product. It means that there is no summation over any axis. Rather, every element of tensor a is multiplied with every element of b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3) (2, 3, 1) (3, 1, 2) (3,)\n",
      "\n",
      "results for the outer product\n",
      "(3, 3)\n",
      "(1, 2, 3, 2, 3, 1)\n",
      "\n",
      "results for the inner product\n",
      "()\n",
      "(3, 1, 3, 1)\n",
      "\n",
      "results for the tensor product\n",
      "(1, 1)\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "print(a.shape, b.shape, c.shape, d.shape)\n",
    "# the outer product\n",
    "print(\"\\nresults for the outer product\")\n",
    "x = np.tensordot(d, d, axes=0)\n",
    "print(x.shape)\n",
    "x = np.tensordot(a, b, axes=0)\n",
    "print(x.shape)\n",
    "\n",
    "# the inner or dot product\n",
    "print(\"\\nresults for the inner product\")\n",
    "x = np.tensordot(d, d, axes=1)\n",
    "print(x.shape)\n",
    "x = np.tensordot(c, b, axes=1)\n",
    "print(x.shape)\n",
    "\n",
    "# the tensor product\n",
    "print(\"\\nresults for the tensor product\")\n",
    "x = np.tensordot(a, b, axes=2)\n",
    "print(x.shape)\n",
    "x = np.tensordot(a, a, axes=3)\n",
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Exercise\n",
    "\n",
    "We denote the tensors a, b, and c as\n",
    "\n",
    "$$ A = a_{i, j, k} \\,\\,\\,\\,\\, B = b_{i, j, k} \\,\\,\\,\\,\\, C = c_{i, j, k} $$\n",
    "\n",
    "- Write down the equation for the outer product, the inner product and the tensor product.\n",
    "- Write down a formula that gives the shape of a given tensor product?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two ways to calculate the tensor product between arbitrary axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n",
      "(1, 2, 3)\n",
      "(2, 1, 3)\n"
     ]
    }
   ],
   "source": [
    "x = np.tensordot(b, a, axes=([0, 2], [1, 0]))\n",
    "print(x.shape)\n",
    "print(a.shape)\n",
    "y = np.swapaxes(a, 0, 1)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shape-mismatch for sum",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-72-8689c5546b36>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# use swapaxes to make the following expressions work\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtensordot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mtensordot\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[0;32m~/env/numpy-course/lib/python3.6/site-packages/numpy/core/numeric.py\u001b[0m in \u001b[0;36mtensordot\u001b[0;34m(a, b, axes)\u001b[0m\n\u001b[1;32m   1074\u001b[0m                 \u001b[0maxes_b\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mndb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1075\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mequal\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1076\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"shape-mismatch for sum\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1077\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1078\u001b[0m     \u001b[0;31m# Move the axes to sum over to the end of \"a\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shape-mismatch for sum"
     ]
    }
   ],
   "source": [
    "# use swapaxes to make the following expressions work\n",
    "x = np.tensordot(a, b, axes=1)\n",
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Exercise\n",
    "\n",
    "In the final exercise we want to bring all the pieces together and take full advantage of what Numpy offers.\n",
    "\n",
    "You are employed by a company that produces `N` types of cars. Each type of car comes in `M` different flavors. For each car and each flavor the company has factories in `L` different countries, each of which has a different VAT: from `0` to `L-1`% for the purchase of material. For each car and flavor there are 100 different materials needed.\n",
    "\n",
    "`def car_production(material, cost_per_material, VAT)\n",
    "    body\n",
    "    return value`\n",
    "\n",
    "1. Write a function that calculates the cost of production for 1 car and 1 flavor in 1 country. The function should be defined like above.  \n",
    "2. Write a function that calculates the cost of production for `N` cars and 1 flavor in 1 country.\n",
    "3. Write a function that calculates the cost of production for `N` cars and `M` flavors in 1 country.\n",
    "4. Write a function that calculates the cost of production for `N` cars and `M` flavors in each of the `L` countries.\n",
    "\n",
    "For this exercise assume you just know the cost of the material and choose these numbers randomly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}