02_Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# NumPy\n",
    "\n",
    "\n",
    "\n",
    "* stellt $n$-dimensionale Arrays (Vektoren, Matrizen,...) zur Verfügung\n",
    "\n",
    "* In C implementiert und auf Geschwindigkeit optimiert. *Deutlich* schneller als Python-Listen\n",
    "\n",
    "* Arrays sind homogen (alle Elemente sind vom gleichen Typ) und haben eine feste Größe (im Gegensatz zu Python-Listen) \n",
    "\n",
    "* Vektorisiert: Arithmetische Operationen und Funktionen arbeiten mit ganzen Arrays und werden elementweise interpretiert.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Zum Nachschlagen/Vertiefen:\n",
    "\n",
    "- [numpy docs](https://numpy.org/doc/1.18/reference/index.html)\n",
    "- [numpy for matlab users](https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html)\n",
    "- [youtube: Intro to Numerical Computing with NumPy (Beginner)](https://www.youtube.com/watch?v=V0D2mhVt7NE) ([hier die Slides](https://github.com/enthought/Numpy-Tutorial-SciPyConf-2019/blob/master/slides.pdf))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Numpy wird in der Regel wie folgt importiert:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### NumPy-Arrays\n",
    "\n",
    "Hauptgegenstand ist numpys `ndarray`-Objekt. Die `np.array()`-Funktion wandelt Listen, Tupeln, ... in numpy-arrays um:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4 5] \n",
      " <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "x = np.array([2,3,4,5])\n",
    "print(x, \"\\n\", type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.         3.14159265]\n",
      " [4.         2.71828183 6.        ]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,np.pi], [4,np.e,6]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Wichtige Eigenschaften eines Array-Objektes können abgefragt werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "(2, 3)\n",
      "6\n",
      "float64\n",
      "8\n",
      "48\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(a.ndim)       # Zahl der Indizes\n",
    "print(a.shape)      # Gestalt, z.B. (n,m) für nxm-Matrix\n",
    "print(a.size)       # Gesamtzahl der Elemente\n",
    "print(a.dtype)      # Datentyp der Elemente\n",
    "print(a.itemsize)   # Größe eines Elements in Bytes \n",
    "print(a.nbytes)     # Größe aller Elemente von a in Bytes\n",
    "print(type(a))      # Typ von a selbst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Warum numpy.arrays statt Python-Listen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "4.22 ms ± 35.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Erstellt eine Liste der Zahlen 1^2, 2^2, 3^3, ..., 10000^2 \n",
    "# inklusive Zeitmessung\n",
    "t1 = %timeit -o [i**2 for i in range(10000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "7.87 µs ± 161 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Nun mit Hilfe eines numpy.arrays\n",
    "t2 = %timeit -o np.arange(10000)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Numpy ist 539 mal schneller!\n"
     ]
    }
   ],
   "source": [
    "print(f\"Numpy ist {t1.best/t2.best:.0f} mal schneller!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hierbei ist `%timeit` ein *Magic*-Befehl, der von der interakten IPythonshell bereitgestellt wird. Er lässt sich also nur innerhalb IPythons oder innerhalb eines Jupyter Notebooks verwenden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Erzeugung von speziellen Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "numpy hat seine eigenen range-Funktion, nämlich\n",
    "\n",
    "`np.arange(start=0, stop, step=1, dtype=None)`\n",
    "\n",
    "`np.linspace(start, stop, num=50, endpoint=True, dtype=None)`\n",
    "\n",
    "welche beide ein numpy-Array erzeugen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(0, 10)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Die `.reshape()`-Funktion kann einen array in einen mit anderer Dimension aber der gleichen Gesamtzahl von Elementen umwandeln. Dabei wird eine Matrix zeilenweise gefüllt. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "b = a.reshape(2,5)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1]\n",
      "  [ 2  3]\n",
      "  [ 4  5]]\n",
      "\n",
      " [[ 6  7]\n",
      "  [ 8  9]\n",
      "  [10 11]]]\n"
     ]
    }
   ],
   "source": [
    "# Hier mal ein Objekt mit 3 Indizes\n",
    "c = np.arange(12).reshape(2, 3, 2)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c_000= 0       c_010= 2         c_101= 7\n"
     ]
    }
   ],
   "source": [
    "print( 'c_000=', c[0,0,0],  '      c_010=', c[0,1,0],  '        c_101=', c[1,0,1]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# array voller Nullen: Das Argument kann eine Zahl, eine Liste [4,3] oder ein Tupel (4,3) sein\n",
    "print(np.zeros([3, 5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "print(np.zeros(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2.01 2.01 2.01 2.01 2.01]\n",
      " [2.01 2.01 2.01 2.01 2.01]\n",
      " [2.01 2.01 2.01 2.01 2.01]]\n"
     ]
    }
   ],
   "source": [
    "# array  mit gegebenem Füllwert\n",
    "print(np.full([3, 5], 2.01))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 0  1  2  3  4]\n [-1  0  1  2  3]\n [-2 -1  0  1  2]\n [-3 -2 -1  0  1]\n [-4 -3 -2 -1  0]\n [-5 -4 -3 -2 -1]]\n"
     ]
    }
   ],
   "source": [
    "# array aus einer mit list comprehension gebildeten Liste\n",
    "x = np.array([[i-j for i in range(5)] for j in range(6)])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[0 0 0 0 0]\n [0 0 0 0 0]\n [0 0 0 0 0]\n [0 0 0 0 0]\n [0 0 0 0 0]\n [0 0 0 0 0]]\n[[1 1 1 1 1]\n [1 1 1 1 1]\n [1 1 1 1 1]\n [1 1 1 1 1]\n [1 1 1 1 1]\n [1 1 1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "# diese Funktion erzeugt eine Nullmatrix / Einsermatrix derselben Gestalt wie das Argument\n",
    "print(np.zeros_like(x))\n",
    "print(np.ones_like(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 1, 2, 3, 4], [-1, 0, 1, 2, 3], [-2, -1, 0, 1, 2], [-3, -2, -1, 0, 1], [-4, -3, -2, -1, 0], [-5, -4, -3, -2, -1]]\n"
     ]
    }
   ],
   "source": [
    "# Man kann aus einem numpy-array auch wieder eine Python-Liste machen:\n",
    "print(x.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# 3x3 Einheitsmatrix \n",
    "print(np.eye(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 0 0]\n",
      " [0 4 0]\n",
      " [0 0 5]]\n"
     ]
    }
   ],
   "source": [
    "# Diagonalmatrix aus 1-dim array \n",
    "print(np.diag([3,4,5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# A.T liefert Transponierte von A\n",
    "print(np.eye(3).T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Zum Plotten von Funktionen recht nützlich ist **linspace**. Im Unterschied zu **arange** gibt man nach Start- und Endwert nicht die Schrittweite sondern die gewünschte Anzahl von (equidistanten) Werten im Intervall an. Der Endwert ist hier in der Folge enthalten.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         1.11111111 1.22222222 1.33333333 1.44444444 1.55555556 1.66666667 1.77777778 1.88888889 2.        ]\n"
     ]
    }
   ],
   "source": [
    "print(np.linspace(1,2,10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Indizes und *Slicing*\n",
    "\n",
    "* __Indices__: Elemente eines arrays kann man über Indizes ansprechen. \n",
    "* __Slicing__: Mit der `n:m:k`-Syntax kann man Teilfelder ansprechen. Dabei ist der Startindex `n` enthalten, **der Endindex `m` ist nicht mehr enthalten** und `k` ist eine optionale Schrittweite. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(x[5]) # Ein Element des Feldes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4 77  6  7  8  9]\n"
     ]
    }
   ],
   "source": [
    "x[5] = 77 # Man kann den Elementen Werte zuweisen\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x[2:7] = [ 2  3  4 77  6]\n"
     ]
    }
   ],
   "source": [
    "print(\"x[2:7] =\", x[2:7]) # Ein Teilfeld"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1 -5 -6  4 77  6  7  8  9]\n"
     ]
    }
   ],
   "source": [
    "# Zuweisung eines Teilfeldes \n",
    "x[2:4] = [-5, -6]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x[0:8:2] = [ 0 -5  4  6]\n",
      "x[:5]    = [ 0  1 -5 -6  4]\n",
      "x[3:]    = [-6  4 77  6  7  8  9]\n",
      "x[:]     = [ 0  1 -5 -6  4 77  6  7  8  9]\n",
      "x[::-1]  = [ 9  8  7  6 77  4 -6 -5  1  0]\n"
     ]
    }
   ],
   "source": [
    "print(\"x[0:8:2] =\", x[0:8:2]) # Teilfeld mit Schrittweite\n",
    "print(\"x[:5]    =\", x[:5])    # fehlender Startindex\n",
    "print(\"x[3:]    =\", x[3:])    # fehlender Endindex\n",
    "print(\"x[:]     =\", x[:])     # fehlender Start- und Endindex\n",
    "print(\"x[::-1]  =\", x[::-1])  # nun mit negativer Schrittweite (also rückwärts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x[7]   =  7\n",
      "x[7:8] =  [7]\n"
     ]
    }
   ],
   "source": [
    "# Es gibt einen Unterschied zwischen x[7] und x[7:8]. Beides addressiert nur \n",
    "# ein Element, aber im 2. Fall erhält man trotzdem einen eindimensionalen Vektor\n",
    "# \n",
    "print(\"x[7]   = \", x[7])   # ein Eleemnt\n",
    "print(\"x[7:8] = \", x[7:8]) # ein (1,)-Vektor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 0  1  2]\n [ 4  5  6]\n [ 8  9 10]]\n"
     ]
    }
   ],
   "source": [
    "# 2-dimensionale Beispiele\n",
    "A = np.array([\n",
    "    [ 0,  1,  2],\n",
    "    [ 4,  5,  6],\n",
    "    [ 8,  9, 10]])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[1]\n [5]] \n\n [[0 1 2]\n [4 5 6]] \n\n [[ 8 10]\n [ 4  6]\n [ 0  2]]\n"
     ]
    }
   ],
   "source": [
    "B = A[0:2, 1:2]\n",
    "C = A[0:2, :]\n",
    "D = A[::-1, ::2]\n",
    "print(B, \"\\n\\n\", C, \"\\n\\n\", D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[ 8 10  4  6  0  2]\n(6,)\n"
     ]
    }
   ],
   "source": [
    "# Umwandeln mehrdimensionaler arrays in ein (m,)-array:\n",
    "print(D.flatten())\n",
    "print(D.flatten().shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Kopien und Views\n",
    "\n",
    "Numpy vermeidet aus Laufzeit- und Speicherplatzgründen das Erstellen von Kopien, solange es nicht unumgänglich oder explizit angewiesen ist. \n",
    "\n",
    "Einfache Zuweisungen \n",
    "```\n",
    "B = A\n",
    "``` \n",
    "oder Slices \n",
    "```\n",
    "B = A[2:3, 4:6]\n",
    "``` \n",
    "erstellen keine Kopie, sondern nur ein *View* auf die existierenden Daten. \n",
    "\n",
    "Vereinfacht ausgedrückt ist ein *View* ein Array, das keinen eigenen Speicherbereich für seine Elemente besitzt, sondern den Speicher eines anderen Arrays nutzt. **Modifizierungen von B modifizieren daher auch A und umgekehrt:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [ 4  5  6]\n",
      " [ 8  9 10]] \n",
      "\n",
      " [[0 1 2]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "B = A\n",
    "C = A[0:2, 0:3]\n",
    "print(B, \"\\n\\n\", C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-99   1   2]\n",
      " [  4   5   6]\n",
      " [  8   9  10]] \n",
      "\n",
      " [[-99   1   2]\n",
      " [  4   5   6]\n",
      " [  8   9  10]] \n",
      "\n",
      " [[-99   1   2]\n",
      " [  4   5   6]]\n"
     ]
    }
   ],
   "source": [
    "A[0,0] = -99\n",
    "print(A, \"\\n\\n\", B, \"\\n\\n\", C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Auch wenn wir ein *View* auf ein array modifizieren, wird das ursprüngliche array verändert:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1000    1    2]\n",
      " [   4    5    6]] \n",
      "\n",
      " [[1000    1    2]\n",
      " [   4    5    6]\n",
      " [   8    9   10]]\n"
     ]
    }
   ],
   "source": [
    "C[0,0] = 1000\n",
    "print(C, \"\\n\\n\", A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Möchte man im Zweifel überprüfen, ob ein array ein View ist, bietet sich das `.flags`-Attribut an:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  C_CONTIGUOUS : True\n",
      "  F_CONTIGUOUS : False\n",
      "  OWNDATA : True\n",
      "  WRITEABLE : True\n",
      "  ALIGNED : True\n",
      "  WRITEBACKIFCOPY : False\n",
      "  UPDATEIFCOPY : False\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(A.flags)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uns interessiert vorerst nur, ob das array auf seinen eigenen Speicherbereich zeigt bzw. ihn \"besitzt\". Also:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A.flags['OWNDATA'] = True\n",
      "C.flags['OWNDATA'] = False\n"
     ]
    }
   ],
   "source": [
    "print(\"A.flags['OWNDATA'] =\", A.flags['OWNDATA']) # A zeigt auf eigenen Speicherbereich (kein View)\n",
    "print(\"C.flags['OWNDATA'] =\", C.flags['OWNDATA']) # C dagegen nicht, also ein View"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Möchte man das array, auf dessen Speicherbereich C zeigt (in unserem Fall A), kann man das `.base`-Attribut\n",
    "verwenden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1000    1    2]\n",
      " [   4    5    6]\n",
      " [   8    9   10]]\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(C.base) # Das ist gerade unser array A\n",
    "print(A.base) # None, da A kein View ist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1000    1    2]\n",
      " [   4    5    6]\n",
      " [   8    9   10]]\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Explizites erstellen einer Kopie\n",
    "B = A.copy()\n",
    "B[0,1] = 9999\n",
    "print(A)\n",
    "print(B.flags['OWNDATA']) # True, da kein View"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### numpy.arrays als Funktionsparameter\n",
    "\n",
    "arrays werden nach dem Prinzip *Call by reference* an eine Funktion übergeben, d.h. es wird weder eine Kopie noch ein View übergeben und es handelt sich um dasselbe Arrayobjekt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(x):\n",
    "    print(\"myfunc: Speicheradresse des Arrays:\", hex(id(x)))\n",
    "    print(\"myfunc: Speicheradresse der Daten: \", hex(x.__array_interface__['data'][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "außerhalb: Speicheradresse des Arrays: 0x11306f620\n",
      "außerhalb: Speicheradresse der Daten:  0x7fbe04119870\n",
      "myfunc: Speicheradresse des Arrays: 0x11306f620\n",
      "myfunc: Speicheradresse der Daten:  0x7fbe04119870\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1,2,3])\n",
    "print(\"außerhalb: Speicheradresse des Arrays:\", hex(id(x)))\n",
    "print(\"außerhalb: Speicheradresse der Daten: \", hex(x.__array_interface__['data'][0]))\n",
    "myfunc(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Advanced Indexing\n",
    "\n",
    "Ein Index kann auch eine Bedingung sein. Dann werden alle Elemente geliefert, die diese\n",
    "Bedingung erfüllen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1000,    4,    5,    6,    8,    9,   10])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[A>3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 1 2]\n",
      " [4 5 5]\n",
      " [5 5 5]]\n"
     ]
    }
   ],
   "source": [
    "# Das ist nützlich, weil man so auf genau diese Elemente  einwirken kann:\n",
    "A[A>5] = 5\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True],\n",
       "       [ True,  True,  True],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Noch allgemeiner: der Vergleich A>5 liefert einen Array aus Wahrheitswerten:\n",
    "A>0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 6])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# und einen solchen Array aus Wahrheitswertne kann man als Index verwenden:\n",
    "B = np.array([1,2,3,4,5,6])\n",
    "C = np.array([False, False, True, False, False, True])\n",
    "B[C]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "###  Iterationen \n",
    "\n",
    "Eine Matrix ist eine Sequenz von Zeilen. \n",
    "\n",
    "Allgemeiner: **`for r in A`**  iteriert  über den am weitesten links stehenden Index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zeile =  [1 2 3]\n",
      "Zeile =  [4 5 6]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "for zeile in A:\n",
    "    print ('Zeile = ', zeile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for zeile in A:\n",
    "    for element in zeile:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a_0,0 = 1\n",
      "a_0,1 = 2\n",
      "a_0,2 = 3\n",
      "a_1,0 = 4\n",
      "a_1,1 = 5\n",
      "a_1,2 = 6\n"
     ]
    }
   ],
   "source": [
    "# diese Funktion liefert einen Iterator mit Indizes:\n",
    "for (i,j), x in np.ndenumerate(A):\n",
    "    print(f\"a_{i},{j} =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Vergleichsoperationen\n",
    "Vergleichsoperationen liefern einen array aus boolschen Werten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(4)\n",
    "x == x[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit den Operatoren **all** und **any** kann man einen `array of bools` reduzieren:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == np.array([0,2,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alles wahr?\n",
    "np.all(x==np.array([0,2,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Irgendwas wahr?\n",
    "np.any(x==np.array([0,2,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Arithmetische Operationen\n",
    "\n",
    "* Arithmetische Operationen werden stets **elementweise** ausgeführt. \n",
    "* Multiplikation ist also nicht die Matrixmultiplikation, Inversion 1/A nicht die Matrixinversion!\n",
    "* Ein Operand kann auch ein Skalar sein. Er wird dann behandelt wie ein Feld der erforderlichen Größe, das mit diesem Skalar gefüllt ist. \n",
    "\n",
    "Da Python objektorientiert ist, wurden die arithmetischen Operatoren (+,-,\\*,\\*\\*,/, usw) für numpy.arrays *überladen*. Das heißt, dass wir eine übersichtliche Syntax haben und in Wirklichkeit (schnelle) numpy-Funktionen aufgerufen werden, wenn man arithmetische Operationen auf numpy.arrays anwendet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 4]\n",
      " [8 9]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[2, 2], [5, 5]])\n",
    "print(a + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.5       ]\n",
      " [0.33333333 0.25      ]]\n"
     ]
    }
   ],
   "source": [
    "print(1/a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4]\n",
      " [15 20]]\n"
     ]
    }
   ],
   "source": [
    "print(a * b) # Nicht mit der Matrizenmultiplikation verwechseln!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3]\n",
      " [4 5]]\n"
     ]
    }
   ],
   "source": [
    "print(a + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[101 102]\n",
      " [103 104]]\n"
     ]
    }
   ],
   "source": [
    "a += 100\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10201 10404]\n",
      " [10609 10816]]\n"
     ]
    }
   ],
   "source": [
    "print(a**2) # Nicht mit der Matrixpotenz verwechseln!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[      10201       10404]\n",
      " [11592740743 12166529024]]\n"
     ]
    }
   ],
   "source": [
    "print(a**b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.45202579  0.99482679]\n",
      " [ 0.62298863 -0.3216224 ]]\n"
     ]
    }
   ],
   "source": [
    "# Auch alle üblichen mathematischen Funktionen werden von numpy so \n",
    "# bereitgestellt, dass sie elementweise auf ein Feld wirken \n",
    "print(np.sin(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Wichtig:** Auch bei den arithmetischen Operationen sollte im Hinblick auf optimale Laufzeit darauf geachtet werden, dass nicht unnötigerweise eine Kopie erstellt wird. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beispiel für eine Kopie:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vorher. Speicheradresse des Arrays: 0x113076bc0\n",
      "Vorher. Speicheradresse der Daten:  0x7fbe01d5f070\n",
      "Nachher. Speicheradresse des Arrays: 0x11308f580\n",
      "Nachher. Speicheradresse der Daten:  0x7fbe01cb7470\n"
     ]
    }
   ],
   "source": [
    "print(\"Vorher. Speicheradresse des Arrays:\", hex(id(a)))\n",
    "print(\"Vorher. Speicheradresse der Daten: \", hex(a.__array_interface__['data'][0]))\n",
    "a = a + 1\n",
    "print(\"Nachher. Speicheradresse des Arrays:\", hex(id(a)))\n",
    "print(\"Nachher. Speicheradresse der Daten: \", hex(a.__array_interface__['data'][0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Während das array mit einer arithmetischen Zuweisung `+= 1` *inplace* verändert wird:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vorher. Speicheradresse des Arrays: 0x11308f580\n",
      "Vorher. Speicheradresse der Daten:  0x7fbe01cb7470\n",
      "Nachher. Speicheradresse des Arrays: 0x11308f580\n",
      "Nachher. Speicheradresse der Daten:  0x7fbe01cb7470\n"
     ]
    }
   ],
   "source": [
    "print(\"Vorher. Speicheradresse des Arrays:\", hex(id(a)))\n",
    "print(\"Vorher. Speicheradresse der Daten: \", hex(a.__array_interface__['data'][0]))\n",
    "a += 1\n",
    "print(\"Nachher. Speicheradresse des Arrays:\", hex(id(a)))\n",
    "print(\"Nachher. Speicheradresse der Daten: \", hex(a.__array_interface__['data'][0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Matrix-Vektor-multiplikationen via `@`-Operator\n",
    "\n",
    "Kann für Matrixprodukt, Matrix-Vektor-produkt and Skalarprodukt verwendet werden.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "26\n[ 3  8 15]\n"
     ]
    }
   ],
   "source": [
    "# shape (3, ) @ (3, ) -> scalar\n",
    "v = np.array([1,2,3])\n",
    "w = np.array([3,4,5])\n",
    "print(v @ w) # Skalarprodukt\n",
    "print(v*w)   # elementweises produkt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[0 1 2]\n [3 4 5]]\n"
     ]
    }
   ],
   "source": [
    "A = np.arange(6).reshape(2,3)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 9 12 15]\n [12 17 22]\n [15 22 29]]\n"
     ]
    }
   ],
   "source": [
    "#  shape (3, 2) @ (2, 3) -> (3, 3)\n",
    "#  ( .T  trasnponiert )\n",
    "print(A.T @ A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[ 5 14]\n [14 50]]\n"
     ]
    }
   ],
   "source": [
    "# shape (2, 3) @ (3, 2) -> (2, 2)\n",
    "print(A @ A.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[ 8 26]\n"
     ]
    }
   ],
   "source": [
    "# shape (2, 3) @ (3,) -> (2, )\n",
    "\n",
    "print(A @ v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[15 24 33]\n"
     ]
    }
   ],
   "source": [
    "# (2, ) @ (2, 3) -> (3,)\n",
    "print(np.array([4,5]) @ A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "Achtung: Möchte man für $u, v \\in \\mathbb{R}^n$ die Matrix $B = u \\cdot v^{\\top} \\in \\mathbb{R}^{n \\times n}$ berechnen, sind arrays mit *shape* `(n,1)` notwendig:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = np.ones(3) # shape (3,)\n",
    "e @ e.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = np.ones(3).reshape(3,1) # shape (3,) zu (3,1)\n",
    "e @ e.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alternativ kann man das äußere (Tensor)-Produkt verwenden:\n",
    "np.outer(e, e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Möchte man für eine quadratische Matrix $A \\in \\mathbb{R}^{n \\times n}$ die Potenz $A^n$ berechnen,\n",
    "bietet sich `matrix_power` an:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.linalg import matrix_power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 13732435440,  17713440288,  21694445136],\n",
       "       [ 42154372512,  54374838624,  66595304736],\n",
       "       [ 70576309584,  91036236960, 111496164336]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.arange(9, dtype=np.int64).reshape(3,3)\n",
    "matrix_power(A, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Reduktionsfunktionen\n",
    "\n",
    "* Reduktionsfunktionen reduzieren die Dimension eines Arrays. \n",
    "* Beispiele: **sum, prod, amin, amax**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1, 18, 7],\n",
    "              [2, 13, 5],\n",
    "              [19, -4, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "62\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "print( np.sum(A) )\n",
    "print( np.amax(A) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22 27 13]\n",
      "\n",
      "[19 18  7]\n"
     ]
    }
   ],
   "source": [
    "# Spaltensumme, größtes Element jeder Spalte\n",
    "print( np.sum( A, axis=0) )\n",
    "print('')\n",
    "print( np.amax(A, axis=0) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[26 20 16]\n",
      "\n",
      "[18 13 19]\n"
     ]
    }
   ],
   "source": [
    "# Zeilensumme, größtes Element jeder Zeile\n",
    "print( np.sum( A, axis=1) )\n",
    "print('')\n",
    "print( np.amax(A, axis=1) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "# Summe der Diagonalelemente\n",
    "print(np.trace(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Vektorisieren\n",
    "\n",
    "Beispiel: Rosenbrockfunktion $f: \\mathbb{R}^n \\to \\mathbb{R}$ mit $f(x) = \\sum_{i=1}^{n-1} 100 \\cdot (x_{i+1}-x_i^2)^2+(1-x_i)^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Möglichkeit 1\n",
    "def rosenbrock1(x):\n",
    "    x = np.asarray(x)\n",
    "    res = 0.0\n",
    "    for i in range(len(x)-1):\n",
    "        res += 100*(x[i+1]-x[i]**2)**2 + (1-x[i])**2\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24 ms ± 447 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit rosenbrock1(np.arange(10000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Möglichkeit 2 (vektorisiert)\n",
    "def rosenbrock2(x):\n",
    "    x = np.asarray(x)\n",
    "    return np.sum(100*(x[1:]-x[:-1]**2)**2 + (1-x[:-1])**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73.3 µs ± 14.4 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit rosenbrock2(np.arange(10000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Performancetipps\n",
    "\n",
    "*What makes Python fast for development is what makes Python slow for code execution. (Jake VanderPlas)*\n",
    "\n",
    "Lösung:\n",
    "\n",
    "- Schleifen möglichst vermeiden, stattdessen vektorisierte numpy-Funktionen (*ufuncs*) verwenden.\n",
    "\n",
    "- Unnötige Arraykopien vermeiden, stattdessen Views verwenden oder direkt *inplace* verändern.\n",
    "\n",
    "- Falls Schleifen unvermeidbar sind und keine passende numpy-Funktion existiert: [Numba](http://numba.pydata.org/) oder [Cython](https://cython.org/).\n",
    "\n",
    "\n",
    "Mehr z.B. unter: [[youtube] Losing your Loops. Fast Numerical Computing with NumPy](https://youtu.be/EEUXKG97YRw)\n"
   ]
  },
  {
   "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}