Blatt6 Lsg und Blatt 7 Bsp.

ec82816e · Frederic Weidling · c093826f · ec82816e · ec82816e
Commit ec82816e authored 8 years ago by Frederic Weidling
--- a/06_Mandelbrot.ipynb
+++ b/06_Mandelbrot.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Aufgabe 23 (Nichtlineare Iterationen)\n",
+    "## Aufgabe:\n",
+    "Für welche $c$ divergiert $z_{n+1}=z_n^2+c$? "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/anaconda/lib/python3.5/site-packages/ipykernel/__main__.py:13: RuntimeWarning: overflow encountered in square\n",
+      "/opt/anaconda/lib/python3.5/site-packages/ipykernel/__main__.py:13: RuntimeWarning: invalid value encountered in square\n",
+      "/opt/anaconda/lib/python3.5/site-packages/ipykernel/__main__.py:18: RuntimeWarning: invalid value encountered in less\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAFjCAYAAABsXjJ7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nzQBCkiRlM4CQJEnZ/j9wJqPpHRTa9wAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x7f6c042b3e80>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Erschaffung eines Gitters\n",
+    "from numpy import ogrid,zeros\n",
+    "\n",
+    "n=100 # Anzahl Unterteilungen eines Einheitsintervalls\n",
+    "\n",
+    "x,y=ogrid[-2:1:(3*n+1)*1j,-1:1:(2*n+1)*1j]\n",
+    "c=x-1j*y # Punkte gewünschter Form\n",
+    "c=c.T # Das transponieren und das Minus in der Zeile darüber sind um sicherzustellen, dass c die gewünschte Orientierung hat\n",
+    "\n",
+    "# Iterieren\n",
+    "z=zeros(c.shape)\n",
+    "for j in range(100):\n",
+    "    z=z**2+c\n",
+    "\n",
+    "# Auswertung des Ergebnis\n",
+    "# Ein genauer Blick hinein zeigt, dass z sehr oft NaN enthält, daher auch die Warnungen.\n",
+    "Z=zeros(c.shape)\n",
+    "Z[abs(z)<100]=1\n",
+    "\n",
+    "# Erstellen des Plots\n",
+    "import matplotlib.pyplot as pyplot\n",
+    "pyplot.spy(Z)\n",
+    "pyplot.show()\n",
+    "# man erhält die Mandelbrotmenge/das Apfelmännchen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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.5.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
+%% Cell type:markdown id: tags:
+
+# Aufgabe 23 (Nichtlineare Iterationen)
+## Aufgabe:
+Für welche $c$ divergiert $z_{n+1}=z_n^2+c$?
+
+%% Cell type:code id: tags:
+
+``` python
+# Erschaffung eines Gitters
+from numpy import ogrid,zeros
+
+n=100 # Anzahl Unterteilungen eines Einheitsintervalls
+
+x,y=ogrid[-2:1:(3*n+1)*1j,-1:1:(2*n+1)*1j]
+c=x-1j*y # Punkte gewünschter Form
+c=c.T # Das transponieren und das Minus in der Zeile darüber sind um sicherzustellen, dass c die gewünschte Orientierung hat
+
+# Iterieren
+z=zeros(c.shape)
+for j in range(100):
+    z=z**2+c
+
+# Auswertung des Ergebnis
+# Ein genauer Blick hinein zeigt, dass z sehr oft NaN enthält, daher auch die Warnungen.
+Z=zeros(c.shape)
+Z[abs(z)<100]=1
+
+# Erstellen des Plots
+import matplotlib.pyplot as pyplot
+pyplot.spy(Z)
+pyplot.show()
+# man erhält die Mandelbrotmenge/das Apfelmännchen
+```
+
+%% Output
+
+    /opt/anaconda/lib/python3.5/site-packages/ipykernel/__main__.py:13: RuntimeWarning: overflow encountered in square
+    /opt/anaconda/lib/python3.5/site-packages/ipykernel/__main__.py:13: RuntimeWarning: invalid value encountered in square
+    /opt/anaconda/lib/python3.5/site-packages/ipykernel/__main__.py:18: RuntimeWarning: invalid value encountered in less
+
+
+
+%% Cell type:code id: tags:
+
+``` python
+```
--- a/07_Fixpunkt_Beispiel.ipynb
+++ b/07_Fixpunkt_Beispiel.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Beispiel: Übergabe von Funktionen\n",
+    "An Hand des Fixpunktiteration wird gezeigt, wie man Funktionen als Argumente an Funktionen übergibt und aufruft. Zunächst die Fixpunktiteration:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "def fixpoint_iteration(phi,x0,tol):\n",
+    "    k=1\n",
+    "    x=phi(x0)\n",
+    "    x_old=x0\n",
+    "    q=0\n",
+    "    \n",
+    "    while True:\n",
+    "        k=k+1\n",
+    "        x_new=phi(x)\n",
+    "        q=max(q,abs((x_new-x)/(x-x_old)))\n",
+    "        if q>=1:\n",
+    "            print('Funktion ist nicht kontraktiv!')\n",
+    "            return\n",
+    "        if q/(1-q)*abs(x_new-x)<=tol:\n",
+    "            return x_new,k\n",
+    "        else:\n",
+    "            x_old=x.copy()\n",
+    "            x=x_new.copy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Jetzt ein Beispiel mit der übergebenen Funktion $\\phi(x)=e^{-x}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Differenz: 2.083e-04, Iterationen: 15\n"
+     ]
+    }
+   ],
+   "source": [
+    "from numpy import exp\n",
+    "\n",
+    "def negativ_exp(x):\n",
+    "    return exp(-x)\n",
+    "\n",
+    "x,k=fixpoint_iteration(negativ_exp,0,1e-3)\n",
+    "print('Differenz: {0:1.3e}, Iterationen: {1}'.format(x-negativ_exp(x),k))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Für solch einfache Beispiele möchte man natürlich nicht immer eine neue Funktion definieren, da Sie eigentlich nur einmal verwendet wird und die Defintion nicht sonderlich schwierig ist. Dafür gibt es _anonyme Funktionen_ in python durch __lambda__ gekennzeichnet. An Hand der selben Funktion wie oben:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fixpunkt: 5.673e-01, Iterationen: 15\n"
+     ]
+    }
+   ],
+   "source": [
+    "x,k=fixpoint_iteration((lambda x: exp(-x)),0,1e-3)\n",
+    "print('Fixpunkt: {0:1.3e}, Iterationen: {1}'.format(x,k))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Insbesondere könnte man jetzt nicht erneut auf die für die Iteration verwendete Funktion zurückgreifen um den Fehler im Fixpunkt zu bestimmen. Aber indem man anonymen Funktionen einen Namhen zuweist geht auch dies. In diesem Fall ist es nur eine schnellere Art eine Funktion zu definieren."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fixpunkt: 2.083e-04, Iterationen: 15\n"
+     ]
+    }
+   ],
+   "source": [
+    "f=(lambda x: exp(-x))\n",
+    "x,k=fixpoint_iteration(f,0,1e-3)\n",
+    "print('Fixpunkt: {0:1.3e}, Iterationen: {1}'.format(x-f(x),k))"
+   ]
+  }
+ ],
+ "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.5.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
+%% Cell type:markdown id: tags:
+
+# Beispiel: Übergabe von Funktionen
+An Hand des Fixpunktiteration wird gezeigt, wie man Funktionen als Argumente an Funktionen übergibt und aufruft. Zunächst die Fixpunktiteration:
+
+%% Cell type:code id: tags:
+
+``` python
+def fixpoint_iteration(phi,x0,tol):
+    k=1
+    x=phi(x0)
+    x_old=x0
+    q=0
+
+    while True:
+        k=k+1
+        x_new=phi(x)
+        q=max(q,abs((x_new-x)/(x-x_old)))
+        if q>=1:
+            print('Funktion ist nicht kontraktiv!')
+            return
+        if q/(1-q)*abs(x_new-x)<=tol:
+            return x_new,k
+        else:
+            x_old=x.copy()
+            x=x_new.copy()
+```
+
+%% Cell type:markdown id: tags:
+
+Jetzt ein Beispiel mit der übergebenen Funktion $\phi(x)=e^{-x}$
+
+%% Cell type:code id: tags:
+
+``` python
+from numpy import exp
+
+def negativ_exp(x):
+    return exp(-x)
+
+x,k=fixpoint_iteration(negativ_exp,0,1e-3)
+print('Differenz: {0:1.3e}, Iterationen: {1}'.format(x-negativ_exp(x),k))
+```
+
+%% Output
+
+    Differenz: 2.083e-04, Iterationen: 15
+
+%% Cell type:markdown id: tags:
+
+Für solch einfache Beispiele möchte man natürlich nicht immer eine neue Funktion definieren, da Sie eigentlich nur einmal verwendet wird und die Defintion nicht sonderlich schwierig ist. Dafür gibt es _anonyme Funktionen_ in python durch __lambda__ gekennzeichnet. An Hand der selben Funktion wie oben:
+
+%% Cell type:code id: tags:
+
+``` python
+x,k=fixpoint_iteration((lambda x: exp(-x)),0,1e-3)
+print('Fixpunkt: {0:1.3e}, Iterationen: {1}'.format(x,k))
+```
+
+%% Output
+
+    Fixpunkt: 5.673e-01, Iterationen: 15
+
+%% Cell type:markdown id: tags:
+
+Insbesondere könnte man jetzt nicht erneut auf die für die Iteration verwendete Funktion zurückgreifen um den Fehler im Fixpunkt zu bestimmen. Aber indem man anonymen Funktionen einen Namhen zuweist geht auch dies. In diesem Fall ist es nur eine schnellere Art eine Funktion zu definieren.
+
+%% Cell type:code id: tags:
+
+``` python
+f=(lambda x: exp(-x))
+x,k=fixpoint_iteration(f,0,1e-3)
+print('Fixpunkt: {0:1.3e}, Iterationen: {1}'.format(x-f(x),k))
+```
+
+%% Output
+
+    Fixpunkt: 2.083e-04, Iterationen: 15