galton_board_manuell.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright © 2020 IUBH Internationale Hochschule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### galton brett \n",
    "\n",
    "\n",
    "**Konzept:** (https://de.wikipedia.org/wiki/Galtonbrett):\n",
    "\n",
    "\"Das Galtonbrett besteht aus einer regelmäßigen Anordnung von Hindernissen, an denen eine von oben eingeworfene Kugel jeweils nach links oder rechts abprallen kann. Nach dem Passieren der Hindernisse werden die Kugeln in Fächern aufgefangen, um dort gezählt zu werden.\" \n",
    "\"... Ein grundlegendes mathematisches Gesetz, der zentrale Grenzwertsatz, garantiert, dass eine nahezu beliebig zusammengesetzte Verteilung solcher sehr kleinen und sehr zahlreichen Einzelstörungen in der Summe gegen die glockenförmige gaußsche Normalverteilung konvergiert. ... Bei einer endlichen Zahl von Störungen, wie beim Galtonbrett, erhält man die Binomialverteilung, die im Grenzwert vieler Störungen und vieler Fächer ebenfalls gegen die Normalverteilung konvergiert, siehe den Grenzwertsatz von Moivre-Laplace.\"\n",
    "\n",
    "**Simulation:**\n",
    "Mit den Klassen 'board', 'kugel' und 'galton-board' kann eine Simulation des Galton-Boards gestartet werden. \n",
    "Das 'board' zeichnet die Behälter und die entsprechenden Hindernisse in Dreiecksform. Jedes Kugel-objekt enthält eine zufällige Bernoulli-Kette über der der Weg durch die Hindernisse bestimmt ist. Der Weg rechts am Hinderniss vorbei entspricht 1, der Weg links am Hindernis vorbei entspricht dem Wert 0.\n",
    "Die Länge der Kette wird über die Anzahl der Slots bestimmt: lKette = nSlots -1\n",
    "Die Anzahl der Hindernisreihen entsprechen der Länge der bernoulli-kette.\n",
    " \n",
    "**Parameter**\n",
    "\n",
    "- nSlots = Anzahl der Behälter        (default = 10)\n",
    "- nBalls = Anzahl der Kugeln          (default = 100)\n",
    "- nInterval = Intervalgeschwindigkeit (default = 1 ms)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %matplotlib notebook\n",
    "%matplotlib widget\n",
    "\n",
    "import numpy as np\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.animation import FuncAnimation\n",
    "from scipy.stats import bernoulli, norm\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class board:\n",
    "    def __init__(self, nSlots, ax, y0, xInterval, yInterval):\n",
    "        self.ax = ax\n",
    "        self.nSlots = nSlots\n",
    "        self.res = np.zeros(nSlots)\n",
    "        self.lenChain = nSlots - 1\n",
    "        self.indexM = np.zeros([self.lenChain, (self.lenChain * 2 - 1)])\n",
    "        #\n",
    "        self.markerSize = 5\n",
    "        self.xInterval = xInterval\n",
    "        self.yInterval = yInterval\n",
    "        self.xOffset = 5\n",
    "        self.y_0 = y0\n",
    "        #\n",
    "        #\n",
    "        self.xLim = [0, (self.xOffset + self.lenChain + self.xOffset -1)]\n",
    "        self.yLim = [0, (self.y_0 * 1.20)]\n",
    "        self.xm = 5\n",
    "    #--------------------------------------------------------------------\n",
    "    def initBoard(self):\n",
    "        \"\"\" \n",
    "        Matrix für Dreieck bilden:\n",
    "        die gleichmäßig verteilten Hindernisse bilden ein Dreieck.\n",
    "        Die Matrix hat folgende Größe: länge der Kette x (2* länge der Kette -1), [2x3, 3x5, 4x7] usw.\n",
    "        \n",
    "                    ***+***  -> Matrix zeilenweise füllen. \n",
    "                    **+*+**  -> Mit letzter Zeile beginnen und index-Vektor \n",
    "                    *+*+*+*  -> Zeile für Zeile verkleinern\n",
    "                    +*+*+*+\n",
    "        \n",
    "        mit Hilfe dieser Matrix werden die Hindernisse als kreisförmige Markierungen in die Figur gezeichnet\n",
    "        \"\"\"\n",
    "        rowIndex = np.arange(0, self.indexM.shape[-1], 2)\n",
    "        for i in list(range((self.lenChain - 1), -1, -1)):\n",
    "            if i == (len(self.indexM)-1):\n",
    "                self.indexM[i][rowIndex] = 1\n",
    "                continue\n",
    "            rowIndex = rowIndex[0:-1] +1\n",
    "            self.indexM[i][rowIndex] = 1\n",
    "        #\n",
    "        # Markierungen zeichnen\n",
    "        #\n",
    "        x = self.xOffset\n",
    "        y = self.y_0\n",
    "        for i in range(0, len(self.indexM)):\n",
    "            x = self.xOffset\n",
    "            for c in range(0, self.indexM.shape[-1]):\n",
    "                if self.indexM[i][c]:\n",
    "                    self.ax.plot(x, y, 'ok', markersize=str(self.markerSize))\n",
    "                x += self.xInterval\n",
    "            y -= self.yInterval\n",
    "\n",
    "        self.ax.set_xlim(self.xLim)\n",
    "        self.ax.set_ylim(self.yLim)\n",
    "        #\n",
    "        # vertikale Linien um die Behälter anzudeuten\n",
    "#         ymax = 2\n",
    "#         self.ax.vlines(x=(self.xOffset - self.xInterval), ymin=0, ymax= ymax, ls=\"-\", lw=3)\n",
    "#         self.ax.vlines(x=(self.xOffset + self.lenChain + self.xInterval - 1), ymin=0, ymax= ymax, ls=\"-\", lw=3)\n",
    "#         vx = np.arange(self.xOffset - 1, self.xOffset + self.lenChain, 1)\n",
    "#         self.ax.vlines(x=vx, ymin=0, ymax =ymax, ls=\"-\", lw=3)\n",
    "        #\n",
    "        # Mitte der Figur:\n",
    "        self.xm = (self.ax.get_xlim()[-1] / 2)\n",
    "        # No ticks\n",
    "        self.ax.set_xticks([])\n",
    "        self.ax.set_yticks([])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Kugel:\n",
    "    \"\"\"\n",
    "    Klasse 'Kugel':  \n",
    "    Ein galton brett enthält x Kugeln, die zufällig durch die Hindernisse fallen und am Ende\n",
    "    in einem Behälter landen. Der Weg der Kugeln wird über eine zufällige Bernoulli-Reihe vorgegeben. Die Kugeln werden\n",
    "    nacheinander durch das Brett geführt.\n",
    "\n",
    "    Member:\n",
    "    - line: lin2D objekt das die Kugel im Diagram representiert\n",
    "    - gltWay: Bernoulli-Reihe mit der Länge nSlots-1\n",
    "    - runIndex: inkremenntierender Index, der zur Steuerung durch das Brett entlang der bernoulli-Kette verwendet wird.\n",
    "        \n",
    "    Methoden:\n",
    "    - move_right(): Kugel nach rechts bewegen\n",
    "    - move_left(): Kugel nach links bewegen\n",
    "    \"\"\"\n",
    "    def __init__(self, ax, gltWay, y0, xInterval, yInterval):\n",
    "        self.x = (ax.get_xlim()[-1] / 2)\n",
    "        self.y = y0 + yInterval\n",
    "        self.xInterval = xInterval\n",
    "        self.yInterval = yInterval\n",
    "        self.line, = ax.plot(self.x, self.y, 'or', markersize=\"8\")\n",
    "        self.color = 'red'\n",
    "        self.gltWay = gltWay\n",
    "        self.gltLen = len(gltWay)\n",
    "        self.runIndex = 0\n",
    "    #\n",
    "    def move_right(self):\n",
    "        if isinstance(self.line.get_data()[0], np.ndarray):\n",
    "            self.x = self.line.get_data()[0][0]\n",
    "            self.y = self.line.get_data()[-1][0]\n",
    "            self.line.set_data(self.x + self.xInterval, self.y - 2)\n",
    "            return\n",
    "        if not isinstance(self.line.get_data()[0], np.ndarray):\n",
    "            self.x = self.line.get_data()[0]\n",
    "            self.y = self.line.get_data()[-1]\n",
    "            self.line.set_data(self.x + self.xInterval, self.y - self.yInterval)\n",
    "        return\n",
    "    #\n",
    "    def move_left(self):\n",
    "        if isinstance(self.line.get_data()[0], np.ndarray):\n",
    "            self.x = self.line.get_data()[0][0]\n",
    "            self.y = self.line.get_data()[-1][0]\n",
    "            self.line.set_data(self.x - self.xInterval, self.y - 2)\n",
    "            return\n",
    "        if not isinstance(self.line.get_data()[0], np.ndarray):\n",
    "            self.x = self.line.get_data()[0]\n",
    "            self.y = self.line.get_data()[-1]\n",
    "            self.line.set_data(self.x - self.xInterval, self.y - self.yInterval)\n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-----------------------------------------------------------------------------------\n",
    "class GaltonBrett:\n",
    "    \"\"\" \n",
    "    Klasse GaltonBrett: Übergeordnete Klasse um die Steuerung der Animation übersichtlicher zu gestalten.\n",
    "                        Klasse enthältt als Member das Board und die Kugeln.\n",
    "    \n",
    "    Member:\n",
    "    - board:      board-objekt \n",
    "    - balls:      Kugel-objekt\n",
    "    - activeBall: index zur Kugel die aktuell durchs Brett geführt wird\n",
    "    - ax:         ax-objekt des Diagrams\n",
    "    - ax2:        2. ax-objekt für 2.y-Achse. Bezug für Ergebnisfitting. \n",
    "    \n",
    "    Methoden:\n",
    "    - getBall(iBall): einzelne Kugel zurückgeben\n",
    "    - getBallsCount(): Anzahl aller Kugeln zurückgeben\n",
    "    - getSlotsCount(): Anzahl der Behälter zurückgeben\n",
    "    - getAxis():       ax-Objekt der Figur zurückgeben\n",
    "    - drawResult():    Gesamtergebnis als bar-plot anzeigen\n",
    "    - clearBall(iBall):    Einzelne Kugel aus dem Diagramm entfernen\n",
    "    \n",
    "    \"\"\" \n",
    "    def __init__(self, ax, nSlots, nBalls):\n",
    "        self.balls = []\n",
    "        self.activeBall = 0\n",
    "        self.ax = ax\n",
    "        \n",
    "        props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n",
    "        self.text = ax.text(0.05, 0.15,'0', transform=self.ax.transAxes, fontsize=10,verticalalignment='top', bbox=props)\n",
    "        self.ax2 = self.ax.twinx()\n",
    "        self.ax2.set_yticks([])\n",
    "        self.xInterval = 0.5\n",
    "        self.yInterval = 1.5\n",
    "        #\n",
    "        if nSlots > 10:\n",
    "            y0 = 15 * self.yInterval\n",
    "        else:\n",
    "            y0 = 15       \n",
    "        #\n",
    "        if nSlots > 10 or nBalls > 20:\n",
    "            y0 = 15 + 0.30*nBalls\n",
    "        #\n",
    "        self.board = board(nSlots, ax, y0, self.xInterval, self.yInterval)\n",
    "        #\n",
    "        # Figur initialisieren:\n",
    "        self.board.initBoard()\n",
    "        #\n",
    "        # Kugeln in liste speichern\n",
    "        lenWay = nSlots-1\n",
    "        self.result = []\n",
    "        for i in range(nBalls):\n",
    "            self.balls.append(Kugel(ax, bernoulli.rvs(0.5, size = lenWay), self.board.y_0, self.board.xInterval, self.board.yInterval))\n",
    "            self.result.append(np.sum(self.balls[i].gltWay))\n",
    "    #\n",
    "    def getBall(self, index):\n",
    "        return self.balls[index]\n",
    "    #\n",
    "    def getBallsCount(self):\n",
    "        return len(self.balls)\n",
    "    #\n",
    "    def getSlotsCount(self):\n",
    "        return self.board.nSlots\n",
    "    #\n",
    "    def getAxis(self):\n",
    "        return self.board.ax\n",
    "    #\n",
    "    def clearBall(self, iBall):\n",
    "        self.balls[iBall].line.remove()\n",
    "    #\n",
    "    def AddBallResult(self, iResult):\n",
    "        self.board.res[iResult] += 1\n",
    "        iMax = self.board.lenChain + self.board.xOffset\n",
    "        x = np.arange(self.board.xOffset -1, iMax, 1)\n",
    "        self.rects = self.board.ax.bar(x, self.board.res , color=\"blue\")\n",
    "#         self.board.ax.bar(self.board.xOffset - self.board.xInterval, self.board.res[0], color=\"blue\" )\n",
    "#         self.board.ax.bar(x, self.board.res[1:len(x)+1] , color=\"blue\")\n",
    "#         self.board.ax.bar(iMax - self.board.xInterval, self.board.res[-1],color=\"blue\")\n",
    "        #\n",
    "    #\n",
    "    def DrawFittingFunction(self, x, y):\n",
    "        # draw fitting with a second y-axis\n",
    "        #\n",
    "        # höhe der einzelnen behälter anzeigen:\n",
    "        #\n",
    "        for rect in self.rects:\n",
    "            height = rect.get_height()\n",
    "            self.board.ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,'%d' % int(height),ha='center', va='bottom')\n",
    "        #\n",
    "        self.ax2.plot(x, y, 'C1')        \n",
    "        self.ax2.set_ylim(0, np.amax(y) * 1.5)\n",
    "#-----------------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_galton(*args):\n",
    "    \"\"\"\n",
    "    update-funktion der Animation\n",
    "    - für jede Kugel durch die Hindernisse und speichert das Ergebnis als bar-plot\n",
    "    - beendet die Animation wenn alle Kugeln durch die Hindernisse gelaufen sind und\n",
    "      fittet eine Normalverteilung aus dem Ergebnis\n",
    "    \"\"\"\n",
    "    #\n",
    "    # Ende der Animation wenn alle Kugeln durch die Hindernisse gelaufen sind\n",
    "    if galton.activeBall >= galton.getBallsCount(): \n",
    "        #\n",
    "        # Ergebnis (behälter-Inhalte) mit einer Normalverteilung fitten\n",
    "        #\n",
    "        # - die ermittelte Normalverteilung wird in die Mitte des boards gelegt.\n",
    "        #\n",
    "#         mu, sigma = norm.fit(np.where(galton.board.res > 0))\n",
    "#         print(\"fitting it board.res > 0:\\tmu: {0:.2f}\\tsigma: {1:.2f}\".format(mu, sigma))\n",
    "        #\n",
    "        fitting = norm.fit(galton.result)\n",
    "#         print(\"fitting mit galton.result:\\tmu: {0:.2f}\\tsigma: {1:.2f}\".format(fitting[0], fitting[1]))\n",
    "        \n",
    "        xFit =  np.arange(galton.ax.get_xlim()[0], galton.ax.get_xlim()[-1], 1/200)\n",
    "        # wenn mu eine ganze Zahl ist, wird die Normalverteilung in der Mitte angezeigt, andernfalls +/- xIntervall versetzt.\n",
    "        #\n",
    "        if (galton.board.nSlots/2 - fitting[0]) == 0:\n",
    "            pdfFit = norm.pdf(xFit, galton.board.xm, fitting[1])\n",
    "        #\n",
    "        if (galton.board.nSlots/2 - fitting[0]) > 0:\n",
    "            pdfFit = norm.pdf(xFit, galton.board.xm - galton.board.xInterval, fitting[1])\n",
    "        #\n",
    "        if (galton.board.nSlots/2 - fitting[0]) < 0:\n",
    "            pdfFit = norm.pdf(xFit, galton.board.xm + galton.board.xInterval, fitting[1])\n",
    "        #\n",
    "        #\n",
    "        textstr = '\\n'.join((\\\n",
    "                             \"Parameter der Normalverteilung\",\n",
    "                             r'$\\mu=%.2f$' % (fitting[0], ),\n",
    "                             r'$\\mathrm{\\sigma}=%.2f$' % (fitting[1], ),\n",
    "                             r'$\\mathrm{max =}%.2f$' %(np.amax(pdfFit), )\n",
    "                             ))\n",
    "        props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n",
    "        galton.ax.text(0.05, 0.95, textstr, transform=galton.ax.transAxes, fontsize=10,\\\n",
    "                       verticalalignment='top', bbox=props)\n",
    "        #\n",
    "        galton.DrawFittingFunction(xFit, pdfFit)\n",
    "        #\n",
    "#         galton.DrawFittingFunction(xFit, norm.pdf(xFit, fitting[0], fitting[1]))\n",
    "        #\n",
    "        anim.event_source.stop()\n",
    "        return galton\n",
    "        #\n",
    "    #\n",
    "    # Kugelobjekt holen, das gerade bewegt werden soll\n",
    "    ActBall = galton.getBall(galton.activeBall)\n",
    "    #\n",
    "    # is die aktuelle Kugel bereits am Ende angelangt?\n",
    "    if ActBall.runIndex >= (ActBall.gltLen - 1):\n",
    "    #\n",
    "        # Behälterinhalt um 1 erhöhen. \n",
    "        galton.AddBallResult(np.sum(ActBall.gltWay))\n",
    "        # Kugel aus Diagram löschen\n",
    "        galton.clearBall(galton.activeBall)\n",
    "        # Kugelzähler um 1 erhöhen\n",
    "        galton.activeBall += 1\n",
    "        return ActBall.line\n",
    "    #\n",
    "    # Kugel am Hindernis links/rechts bewegen\n",
    "    if ActBall.runIndex < ActBall.gltLen:\n",
    "        if ActBall.gltWay[ActBall.runIndex] > 0:\n",
    "            ActBall.move_right()\n",
    "        #\n",
    "        if ActBall.gltWay[ActBall.runIndex] == 0:\n",
    "            ActBall.move_left()\n",
    "        #\n",
    "    ActBall.runIndex += 1\n",
    "    galton.text.set_text(r'$\\Sigma = %d$' %(galton.activeBall +1, ))\n",
    "\n",
    "    \n",
    "    return ActBall.line\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameter der Simulation\n",
    "#\n",
    "nSlots = 13\n",
    "nBalls = 50\n",
    "nInterval = 100\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "192f01dc2de14dd5853d822716b61355",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Animation mit obigen Parametern starten\n",
    "# \n",
    "fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(10,6))\n",
    "#\n",
    "galton = GaltonBrett(axes, nSlots, nBalls)\n",
    "#\n",
    "anim = FuncAnimation(fig, run_galton, interval=nInterval, blit=True)\n",
    "#\n",
    "# historgram and gaussian-fit\n",
    "#\n",
    "# axes[1].hist(galton.result, bins=nSlots, density=True, label='experiment')\n",
    "#\n",
    "fitting = norm.fit(galton.result)\n",
    "xLim = axes.get_xlim()\n",
    "x2 = np.arange(xLim[0], xLim[-1], 1/200)\n",
    "# axes[1].plot(x2, norm.pdf(x2, fitting[0], fitting[1]), label='gaussian fit')\n",
    "#\n",
    "# axes[1].set_xticks([])\n",
    "# axes[1].set_yticks([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright © 2020 IUBH Internationale Hochschule"
   ]
  }
 ],
 "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.8.2"
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}