{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zufallszahlenlabor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Beispiel: Poisson-Verteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 49048 characters]",
      "text/plain": [
       "<Figure size 1800x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Mittlere Tore Heim: 1.80, Standardabweichung: 1.34\n",
      "Mittlere Tore Auswärts: 1.30, Standardabweichung: 1.14\n",
      "Mittlere Tordifferenz: 0.50, Standardabweichung: 1.76\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(11)\n",
    "\n",
    "# gegebenen Parameter\n",
    "anzahl_fussballspiele = 1000000\n",
    "tore_heim_avg = 1.8\n",
    "tore_auswaerts_avg = 1.3\n",
    "\n",
    "# Erstellung einer Poison-Verteilung\n",
    "# Simulation der geschossenen Tore\n",
    "tore_heim = np.random.poisson(tore_heim_avg, anzahl_fussballspiele)\n",
    "tore_auswaerts = np.random.poisson(tore_auswaerts_avg, anzahl_fussballspiele)\n",
    "\n",
    "# Berechnung der Tordifferenz\n",
    "tordifferenz = tore_heim - tore_auswaerts\n",
    "\n",
    "# Plot der Verteilungen\n",
    "fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n",
    "\n",
    "# Verteilung der geschossenen Tore der Heimmannschaft\n",
    "values, counts = np.unique(tore_heim, return_counts=True)\n",
    "probs = counts / anzahl_fussballspiele\n",
    "axes[0].bar(values, probs, alpha=0.7, color='blue', edgecolor='black')\n",
    "axes[0].set_title('Verteilung der Tore (Heimmannschaft)')\n",
    "axes[0].set_xlabel('Anzahl Tore')\n",
    "axes[0].set_ylabel('Häufigkeit')\n",
    "\n",
    "# Verteilung der geschossenen Tore der Gastmannschaft\n",
    "values, counts = np.unique(tore_auswaerts, return_counts=True)\n",
    "probs = counts / anzahl_fussballspiele\n",
    "axes[1].bar(values, probs, alpha=0.7, color='green', edgecolor='black')\n",
    "axes[1].set_title('Verteilung der Tore (Gastmannschaft)')\n",
    "axes[1].set_xlabel('Anzahl Tore')\n",
    "axes[1].set_ylabel('Häufigkeit')\n",
    "\n",
    "# Verteilung der Tordifferenz\n",
    "values, counts = np.unique(tordifferenz, return_counts=True)\n",
    "probs = counts / anzahl_fussballspiele\n",
    "axes[2].bar(values, probs, alpha=0.7, color='red', edgecolor='black')\n",
    "axes[2].set_title('Verteilung der Tordifferenz')\n",
    "axes[2].set_xlabel('Tordifferenz')\n",
    "axes[2].set_ylabel('Häufigkeit')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Mittlere Tore Heim: {np.mean(tore_heim):.2f}, Standardabweichung: {np.std(tore_heim):.2f}\")\n",
    "print(f\"Mittlere Tore Auswärts: {np.mean(tore_auswaerts):.2f}, Standardabweichung: {np.std(tore_auswaerts):.2f}\")\n",
    "print(f\"Mittlere Tordifferenz: {np.mean(tordifferenz):.2f}, Standardabweichung: {np.std(tordifferenz):.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Beispiel: Geometrische Verteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 35996 characters]",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Mittlere Tage seit letztem Fehler: 125.04\n",
      "Standardabweichung: 124.51\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(22)\n",
    "\n",
    "# Parameter fuer die geometrische Verteilung\n",
    "durchschnitt_tage = 125\n",
    "anzahl_maschinen = 1000000\n",
    "\n",
    "# Simulation der Tage seit letztem Fehler\n",
    "tage_seit_letztem_fehler = np.random.geometric(1/durchschnitt_tage, anzahl_maschinen)\n",
    "\n",
    "# Plot der Verteilung\n",
    "values, counts = np.unique(tage_seit_letztem_fehler, return_counts=True)\n",
    "probs = counts / anzahl_maschinen\n",
    "\n",
    "plt.bar(values, probs, alpha=0.7, color='purple', edgecolor='black')\n",
    "plt.title('Verteilung der Tage seit letztem Fehler')\n",
    "plt.xlabel('Tage seit letztem Fehler')\n",
    "plt.ylabel('Häufigkeit')\n",
    "plt.show()\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Mittlere Tage seit letztem Fehler: {np.mean(tage_seit_letztem_fehler):.2f}\")\n",
    "print(f\"Standardabweichung: {np.std(tage_seit_letztem_fehler):.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Beispiel: Binomialverteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n = 10000, p = 0.08333333333333333, size = 1000000\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 28484 characters]",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Mittlere Anzahl Kunden: 833.35\n",
      "Standardabweichung: 27.63\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(33)\n",
    "\n",
    "# Parameter fuer die Binomialverteilung\n",
    "anzahl_tage = 1_000_000\n",
    "anzahl_kunden_pro_tag = 10_000\n",
    "laden_oeffnungszeiten = 12  # Stunden\n",
    "zeit_kunden_einkaufen = 1  # Stunde\n",
    "p = zeit_kunden_einkaufen / laden_oeffnungszeiten  # Wahrscheinlichkeit, dass ein Kunde im Laden ist\n",
    "\n",
    "# Simulation der Anzahl der Kunden, die in einer Stunde einkaufen\n",
    "print(f\"n = {anzahl_kunden_pro_tag}, p = {p}, size = {anzahl_tage}\")\n",
    "anzahl_kunden = np.random.binomial(anzahl_kunden_pro_tag, p, anzahl_tage)\n",
    "\n",
    "# Plot der Verteilung\n",
    "values, counts = np.unique(anzahl_kunden, return_counts=True)\n",
    "probs = counts / anzahl_tage\n",
    "\n",
    "plt.bar(values, probs, alpha=0.7, color='orange')\n",
    "plt.title('Verteilung der Anzahl der Kunden im Laden')\n",
    "plt.xlabel('Anzahl Kunden pro Stunde')\n",
    "plt.ylabel('Häufigkeit')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Mittlere Anzahl Kunden: {np.mean(anzahl_kunden):.2f}\")\n",
    "print(f\"Standardabweichung: {np.std(anzahl_kunden):.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Beispiel: Exponentialverteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 35880 characters]",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Mittlerer Schaden: 2358.45 Euro\n",
      "Standardabweichung: 2362.62 Euro\n",
      "Maximaler Schaden: 37886.00 Euro\n",
      "Minimaler Schaden: 0.01 Euro\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# gegebene Parameter\n",
    "anzahl_schaeden = 21_961_000\n",
    "gesamt_schaden = 51_792_000_000 # Euro\n",
    "n = 1_000_000 # Anzahl der Simulationen\n",
    "\n",
    "# # Simulation der Schadenshöhe (Exponentialverteilung)\n",
    "schaden = np.random.exponential(gesamt_schaden / anzahl_schaeden, n)\n",
    "\n",
    "# # Plot der Verteilung als Histogramm\n",
    "plt.hist(schaden, bins=100, density=True, alpha=0.7, color='blue', edgecolor='black')\n",
    "plt.title('Verteilung der Schadenshöhe')\n",
    "plt.xlabel('Schadenhöhe (Euro)')\n",
    "plt.ylabel('Häufigkeit')\n",
    "plt.grid(axis='y', alpha=0.75)\n",
    "plt.show()\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Mittlerer Schaden: {np.mean(schaden):.2f} Euro\")\n",
    "print(f\"Standardabweichung: {np.std(schaden):.2f} Euro\")\n",
    "print(f\"Maximaler Schaden: {np.max(schaden):.2f} Euro\")\n",
    "print(f\"Minimaler Schaden: {np.min(schaden):.2f} Euro\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Beispiel: Gammaverteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 39028 characters]",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Mittlerer Schaden: 2359.38 Euro\n",
      "Standardabweichung: 1179.87 Euro\n",
      "Maximaler Schaden: 11729.62 Euro\n",
      "Minimaler Schaden: 44.03 Euro\n"
     ]
    }
   ],
   "source": [
    "# gegebene Parameter\n",
    "anzahl_schaeden = 21_961_000\n",
    "gesamt_schaden = 51_792_000_000 # Euro\n",
    "avg_schaden = gesamt_schaden / anzahl_schaeden # Durchschnittlicher Schaden\n",
    "std_schaden = avg_schaden / 2 # Standardabweichung\n",
    "n = 1_000_000 # Anzahl der Simulationen\n",
    "varianz_schaden = std_schaden ** 2 # Varianz\n",
    "\n",
    "\n",
    "# Simulation der Schadenshöhe (Gammaverteilung)\n",
    "import numpy as np\n",
    "\n",
    "# shape ist p und scale ist 1/b\n",
    "shape = (avg_schaden ** 2) / varianz_schaden\n",
    "scale = varianz_schaden / avg_schaden\n",
    "\n",
    "schaden = np.random.gamma(shape, scale, n)\n",
    "\n",
    "# Plot der Verteilung als Histogramm\n",
    "plt.hist(schaden, bins=100, density=True, alpha=0.7, color='blue', edgecolor='blue')\n",
    "plt.title('Verteilung der Schadenshöhe (Gamma-Verteilung)')\n",
    "plt.xlabel('Schadenhöhe (Euro)')\n",
    "plt.ylabel('Häufigkeit')\n",
    "plt.grid(axis='y', alpha=0.75)\n",
    "plt.show()\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Mittlerer Schaden: {np.mean(schaden):.2f} Euro\")\n",
    "print(f\"Standardabweichung: {np.std(schaden):.2f} Euro\")\n",
    "print(f\"Maximaler Schaden: {np.max(schaden):.2f} Euro\")\n",
    "print(f\"Minimaler Schaden: {np.min(schaden):.2f} Euro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Beispiel: Log-Normalverteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 30708 characters]",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Mittleres Jahreseinkommen: 27520.03 Euro\n",
      "Standardabweichung: 16894.37 Euro\n",
      "Maximaler Jahreseinkommen: 467172.37 Euro\n",
      "Minimaler Jahreseinkommen: 1303.06 Euro\n"
     ]
    }
   ],
   "source": [
    "# gegebene Parameter\n",
    "avg_jahreseinkommen = 27_520 # Euro\n",
    "median_jahreseinkommen = 23_460 # Euro\n",
    "n = 1_000_000 # Anzahl der Simulationen\n",
    "\n",
    "# Simulation der Jahreseinkommen (Lognormalverteilung)\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Berechnung der Parameter fuer die Lognormalverteilung\n",
    "mu = np.log(median_jahreseinkommen)\n",
    "\n",
    "# Berechnung von sigma mit der variable mu\n",
    "sigma = np.sqrt((np.log(avg_jahreseinkommen)- mu) * 2)\n",
    "\n",
    "jahreseinkommen = np.random.lognormal(mu, sigma, n)\n",
    "\n",
    "# Plot der Verteilung als Histogramm\n",
    "plt.hist(jahreseinkommen, bins=100, density=True, alpha=0.7, color='blue', edgecolor='blue')\n",
    "plt.title('Verteilung der Jahreseinkommen (Lognormalverteilung)')\n",
    "plt.xlabel('Jahreseinkommen (Euro)')\n",
    "plt.ylabel('Häufigkeit')\n",
    "plt.grid(axis='y', alpha=0.75)\n",
    "plt.show()\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Mittleres Jahreseinkommen: {np.mean(jahreseinkommen):.2f} Euro\")\n",
    "print(f\"Standardabweichung: {np.std(jahreseinkommen):.2f} Euro\")\n",
    "print(f\"Maximaler Jahreseinkommen: {np.max(jahreseinkommen):.2f} Euro\")\n",
    "print(f\"Minimaler Jahreseinkommen: {np.min(jahreseinkommen):.2f} Euro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Beispiel: Beta-Verteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 30904 characters]",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Mittlerer BMI: 26.00\n",
      "Standardabweichung: 3.05\n",
      "Maximaler BMI: 38.31\n",
      "Minimaler BMI: 18.21\n"
     ]
    }
   ],
   "source": [
    "# gegebene Parameter\n",
    "anzahl_personen = 1_000_000\n",
    "bmi_untere_grenze = 18\n",
    "bmi_obere_grenze = 40\n",
    "b = bmi_obere_grenze - bmi_untere_grenze\n",
    "a = bmi_untere_grenze\n",
    "mu = 26 # Durchschnittlicher BMI\n",
    "\n",
    "# alpha und beta fuer die Beta-Verteilung\n",
    "alpha = 4\n",
    "beta = 7\n",
    "\n",
    "\n",
    "# Simulation der BMI-Werte (Beta-Verteilung)\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Erzeugung der Beta-Verteilung\n",
    "x = np.random.beta(alpha, beta, anzahl_personen)\n",
    "bmi = a + b * x\n",
    "\n",
    "# Plot der Verteilung als Histogramm\n",
    "plt.hist(bmi, bins=100, density=True, alpha=0.7, color='blue', edgecolor='blue')\n",
    "plt.title('Verteilung der BMI-Werte (Beta-Verteilung)')\n",
    "plt.xlabel('BMI-Wert')\n",
    "plt.ylabel('Häufigkeit')\n",
    "plt.grid(axis='y', alpha=0.75)\n",
    "plt.show()\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Mittlerer BMI: {np.mean(bmi):.2f}\")\n",
    "print(f\"Standardabweichung: {np.std(bmi):.2f}\")\n",
    "print(f\"Maximaler BMI: {np.max(bmi):.2f}\")\n",
    "print(f\"Minimaler BMI: {np.min(bmi):.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Multivariate Normalverteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 192980 characters]",
      "text/plain": [
       "<Figure size 1000x800 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Sentiment: Mittelwert = -0.0006, Std = 1.0001\n",
      "Rendite: Mittelwert = 0.0015, Std = 0.0600\n",
      "Korrelation der erzeugten Zufallszahlenpaare: 0.5992\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Parameter\n",
    "n = 1_000_000\n",
    "mu_sentiment = 0\n",
    "sigma_sentiment = 1\n",
    "mu_rendite = 0.0015\n",
    "sigma_rendite = 0.06\n",
    "\n",
    "# Korrelation\n",
    "r = 0.6\n",
    "\n",
    "# Kovarianzmatrix\n",
    "cov = [[sigma_sentiment**2, r * sigma_sentiment * sigma_rendite],\n",
    "    [r * sigma_sentiment * sigma_rendite, sigma_rendite**2]]\n",
    "\n",
    "mean = [mu_sentiment, mu_rendite]\n",
    "\n",
    "# Zufallszahlen erzeugen\n",
    "data = np.random.multivariate_normal(mean, cov, n)\n",
    "sentiment = data[:, 0]\n",
    "rendite = data[:, 1]\n",
    "\n",
    "# Streudiagramm und Randverteilungen\n",
    "fig = plt.figure(figsize=(10, 8))\n",
    "gs = fig.add_gridspec(2, 2, width_ratios=(7, 2), height_ratios=(2, 7),\n",
    "             wspace=0.05, hspace=0.05)\n",
    "\n",
    "ax_scatter = fig.add_subplot(gs[1, 0])\n",
    "ax_histx = fig.add_subplot(gs[0, 0], sharex=ax_scatter)\n",
    "ax_histy = fig.add_subplot(gs[1, 1], sharey=ax_scatter)\n",
    "\n",
    "# Streudiagramm\n",
    "ax_scatter.scatter(sentiment, rendite, alpha=0.05, s=1)\n",
    "ax_scatter.set_xlabel('Social Media Sentiment')\n",
    "ax_scatter.set_ylabel('Wöchentliche Rendite')\n",
    "\n",
    "# Histogramme\n",
    "ax_histx.hist(sentiment, bins=100, color='blue', alpha=0.7)\n",
    "ax_histy.hist(rendite, bins=100, orientation='horizontal', color='green', alpha=0.7)\n",
    "\n",
    "ax_histx.axis('off')\n",
    "ax_histy.axis('off')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Sentiment: Mittelwert = {np.mean(sentiment):.4f}, Std = {np.std(sentiment):.4f}\")\n",
    "print(f\"Rendite: Mittelwert = {np.mean(rendite):.4f}, Std = {np.std(rendite):.4f}\")\n",
    "\n",
    "# Korrelation bestimmen\n",
    "korrelation = np.corrcoef(sentiment, rendite)[0, 1]\n",
    "print(f\"Korrelation der erzeugten Zufallszahlenpaare: {korrelation:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multivariate Zufallszahlen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 44156 characters]",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Mittlere Anzahl Zimmer: 2.30\n",
      "Standardabweichung Anzahl Zimmer: 1.14\n",
      "Mittlere Wohnungsgröße: 49.42 m²\n",
      "Standardabweichung Wohnungsgröße: 32.91 m²\n",
      "Korrelation zwischen Anzahl Zimmer und Wohnungsgröße: 0.6244\n"
     ]
    }
   ],
   "source": [
    "# gegebene Parameter\n",
    "anzahl_zufallszahlen = 1_000_000\n",
    "p_lambda = 1.3\n",
    "e_lambda = 0.1\n",
    "\n",
    "# Simulation der Poisson-Verteilung\n",
    "import numpy as np\n",
    "Pj = np.random.poisson(p_lambda, anzahl_zufallszahlen)\n",
    "\n",
    "# Simulation der Exponentialverteilung\n",
    "Ej = np.random.exponential(1/e_lambda, anzahl_zufallszahlen)\n",
    "\n",
    "anzahl_zimmer = Pj + 1\n",
    "wohnungsgroesse = 8 + 8 * anzahl_zimmer + Ej * anzahl_zimmer\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(anzahl_zimmer, wohnungsgroesse)\n",
    "plt.xlabel('Anzahl Zimmer')\n",
    "plt.ylabel('Wohnungsgröße (m²)')\n",
    "plt.title('Streudiagramm: Anzahl Zimmer vs. Wohnungsgröße')\n",
    "plt.show()\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Mittlere Anzahl Zimmer: {np.mean(anzahl_zimmer):.2f}\")\n",
    "print(f\"Standardabweichung Anzahl Zimmer: {np.std(anzahl_zimmer):.2f}\")\n",
    "print(f\"Mittlere Wohnungsgröße: {np.mean(wohnungsgroesse):.2f} m²\")\n",
    "print(f\"Standardabweichung Wohnungsgröße: {np.std(wohnungsgroesse):.2f} m²\")\n",
    "\n",
    "# Korrelation der Zufallszahlenpaare\n",
    "korrelation = np.corrcoef(anzahl_zimmer, wohnungsgroesse)[0, 1]\n",
    "print(f\"Korrelation zwischen Anzahl Zimmer und Wohnungsgröße: {korrelation:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 121604 characters]",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lage- und Streuungsmaße:\n",
      "Mittlere Körpergröße: 170.01 cm\n",
      "Standardabweichung Körpergröße: 9.99 cm\n",
      "Mittleres Gewicht: 75.42 kg\n",
      "Standardabweichung Gewicht: 13.04 kg\n",
      "Korrelation zwischen Körpergröße und Gewicht: 0.6781\n"
     ]
    }
   ],
   "source": [
    "# gegebene Parameter\n",
    "anzahl_zufallszahlen = 1_000_000\n",
    "mu = 170\n",
    "sigma = 10\n",
    "q_beta = 6\n",
    "p_beta = 8/14 * q_beta\n",
    "\n",
    "import numpy as np\n",
    "Xj = np.random.normal(mu, sigma, anzahl_zufallszahlen)\n",
    "Bj = np.random.beta(p_beta, q_beta, anzahl_zufallszahlen)\n",
    "\n",
    "Yj = (Xj/100)**2 * (18 + 22 * Bj)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(Xj, Yj, alpha=0.1)\n",
    "plt.xlabel('Körpergröße (cm)')\n",
    "plt.ylabel('Gewicht (kg)')\n",
    "plt.title('Streudiagramm: Körpergröße vs. Gewicht')\n",
    "plt.show()\n",
    "\n",
    "# Lage- und Streuungsmaße\n",
    "print(\"Lage- und Streuungsmaße:\")\n",
    "print(f\"Mittlere Körpergröße: {np.mean(Xj):.2f} cm\")\n",
    "print(f\"Standardabweichung Körpergröße: {np.std(Xj):.2f} cm\")\n",
    "print(f\"Mittleres Gewicht: {np.mean(Yj):.2f} kg\")\n",
    "print(f\"Standardabweichung Gewicht: {np.std(Yj):.2f} kg\")\n",
    "\n",
    "# Korrelation der Zufallszahlenpaare\n",
    "korrelation = np.corrcoef(Xj, Yj)[0, 1]\n",
    "print(f\"Korrelation zwischen Körpergröße und Gewicht: {korrelation:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Modellierung der abhangigen Variablen in der Simulationsstudie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Varianz der Residuen (β0=0, β1=0): 0.2500\n",
      "Varianz der Residuen (β0=-500, β1=1000): 0.0013\n",
      "Varianz der Residuen (β0=-3, β1=6): 0.1496\n"
     ]
    },
    {
     "data": {
      "image/png": "[encoded data, 92536 characters]",
      "text/plain": [
       "<Figure size 1200x1200 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.special import expit as sigmoid\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Parameter\n",
    "anzahl_elemente = 10_000\n",
    "parameter_sets = [\n",
    "    (0, 0),\n",
    "    (-500, 1000),\n",
    "    (-3, 6)\n",
    "]\n",
    "\n",
    "xi = np.random.uniform(0, 1, anzahl_elemente)\n",
    "\n",
    "results = []\n",
    "\n",
    "for beta_0, beta_1 in parameter_sets:\n",
    "    pi = sigmoid(beta_0 + beta_1 * xi)\n",
    "    yi = np.random.binomial(1, pi)\n",
    "    residuen = yi - pi\n",
    "    results.append({\n",
    "        'beta_0': beta_0,\n",
    "        'beta_1': beta_1,\n",
    "        'pi': pi,\n",
    "        'yi': yi,\n",
    "        'residuen': residuen,\n",
    "        'varianz_residuen': np.var(residuen)\n",
    "    })\n",
    "\n",
    "fig, axes = plt.subplots(3, 2, figsize=(12, 12))\n",
    "for i, res in enumerate(results):\n",
    "    axes[i, 0].hist(res['pi'], bins=50, color='skyblue', edgecolor='black')\n",
    "    axes[i, 0].set_title(f'Verteilung pi (β0={res[\"beta_0\"]}, β1={res[\"beta_1\"]})')\n",
    "    axes[i, 0].set_xlabel('pi')\n",
    "    axes[i, 0].set_ylabel('Häufigkeit')\n",
    "    \n",
    "    axes[i, 1].hist(res['yi'], bins=2, color='orange', edgecolor='black', rwidth=0.8)\n",
    "    axes[i, 1].set_title(f'Verteilung yi (β0={res[\"beta_0\"]}, β1={res[\"beta_1\"]})')\n",
    "    axes[i, 1].set_xlabel('yi')\n",
    "    axes[i, 1].set_ylabel('Häufigkeit')\n",
    "    \n",
    "    print(f\"Varianz der Residuen (β0={res['beta_0']}, β1={res['beta_1']}): {res['varianz_residuen']:.4f}\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Häufigkeitstabelle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 41480 characters]",
      "text/plain": [
       "<Figure size 1400x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vorgegebene Häufigkeitstabelle:\n",
      "      bis 20  ueber 20 bis 40  ueber 40 bis 60  ueber 60 bis 80  ueber 80\n",
      "Mann   10000            15000            10000             5000      5000\n",
      "Frau   18000            11000            14000             7000      5000\n",
      "\n",
      "Simulierte Häufigkeitstabelle:\n",
      "Alter       bis 20  ueber 20 bis 40  ueber 40 bis 60  ueber 60 bis 80  \\\n",
      "Geschlecht                                                              \n",
      "Frau         17915            11036            13993             6945   \n",
      "Mann         10094            14974            10016             5145   \n",
      "\n",
      "Alter       ueber 80  \n",
      "Geschlecht            \n",
      "Frau            4999  \n",
      "Mann            4883  \n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Vorgabeverteilung\n",
    "alter_klassen = ['bis 20', 'ueber 20 bis 40', 'ueber 40 bis 60', 'ueber 60 bis 80', 'ueber 80']\n",
    "maenner = np.array([10_000, 15_000, 10_000, 5_000, 5_000])\n",
    "frauen = np.array([18_000, 11_000, 14_000, 7_000, 5_000])\n",
    "\n",
    "gesamt_maenner = maenner.sum()\n",
    "gesamt_frauen = frauen.sum()\n",
    "gesamt = gesamt_maenner + gesamt_frauen\n",
    "\n",
    "# Wahrscheinlichkeiten fuer Geschlecht\n",
    "p_maenner = gesamt_maenner / gesamt\n",
    "p_frauen = gesamt_frauen / gesamt\n",
    "\n",
    "# Bedingte Wahrscheinlichkeiten fuer Alter gegeben Geschlecht\n",
    "p_alter_maenner = maenner / gesamt_maenner\n",
    "p_alter_frauen = frauen / gesamt_frauen\n",
    "\n",
    "n = 100_000\n",
    "\n",
    "# Simuliere Geschlecht\n",
    "geschlecht = np.random.choice(['Mann', 'Frau'], size=n, p=[p_maenner, p_frauen])\n",
    "\n",
    "# Simuliere Alter bedingt auf Geschlecht\n",
    "alter = []\n",
    "for g in geschlecht:\n",
    "    if g == 'Mann':\n",
    "        alter.append(np.random.choice(alter_klassen, p=p_alter_maenner))\n",
    "    else:\n",
    "        alter.append(np.random.choice(alter_klassen, p=p_alter_frauen))\n",
    "alter = np.array(alter)\n",
    "\n",
    "# Häufigkeitstabelle simuliert\n",
    "simuliert = pd.crosstab(geschlecht, alter, rownames=['Geschlecht'], colnames=['Alter'])\n",
    "\n",
    "# Häufigkeitstabelle vorgegeben\n",
    "vorgegeben = pd.DataFrame({'bis 20': [maenner[0], frauen[0]],\n",
    "                           'ueber 20 bis 40': [maenner[1], frauen[1]],\n",
    "                           'ueber 40 bis 60': [maenner[2], frauen[2]],\n",
    "                           'ueber 60 bis 80': [maenner[3], frauen[3]],\n",
    "                           'ueber 80': [maenner[4], frauen[4]]},\n",
    "                          index=['Mann', 'Frau'])\n",
    "\n",
    "# Grafische Darstellung\n",
    "fig, axes = plt.subplots(1, 2, figsize=(14, 6), sharey=True)\n",
    "vorgegeben.T.plot(kind='bar', stacked=True, ax=axes[0], color=['blue', 'red'])\n",
    "axes[0].set_title('Vorgegebene Verteilung')\n",
    "axes[0].set_ylabel('Anzahl')\n",
    "axes[0].set_xlabel('Alter')\n",
    "simuliert.T.plot(kind='bar', stacked=True, ax=axes[1], color=['blue', 'red'])\n",
    "axes[1].set_title('Simulierte Verteilung')\n",
    "axes[1].set_xlabel('Alter')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "print(\"Vorgegebene Häufigkeitstabelle:\")\n",
    "print(vorgegeben)\n",
    "print(\"\\nSimulierte Häufigkeitstabelle:\")\n",
    "print(simuliert)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bedingte Verteilung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 33736 characters]",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "np.random.seed(11)\n",
    "\n",
    "n = 1_000_000\n",
    "anzahl_kunden_pro_tag = 10_000\n",
    "laden_oeffnungszeiten = 12\n",
    "\n",
    "tageszeiten = ['Früh', 'Vormittag', 'Nachmittag', 'Abend']\n",
    "anteile = np.array([0.35, 0.05, 0.20, 0.40])\n",
    "\n",
    "# Simulation\n",
    "sim_tageszeit = np.random.choice(tageszeiten, size=n, p=anteile)\n",
    "\n",
    "# Berechnung der Anzahl Kunden pro Tageszeit\n",
    "anzahl_kunden = np.zeros(len(tageszeiten))\n",
    "for i, t in enumerate(tageszeiten):\n",
    "    anzahl_kunden[i] = np.random.binomial(anzahl_kunden_pro_tag, anteile[i], n).mean()\n",
    "\n",
    "df = pd.DataFrame({\n",
    "    'Tageszeit': tageszeiten,\n",
    "    'Anzahl Kunden': anzahl_kunden\n",
    "})\n",
    "\n",
    "# Plot der Verteilung\n",
    "for i, t in enumerate(tageszeiten):\n",
    "    plt.bar(t, anzahl_kunden[i], label=t, alpha=0.7)\n",
    "plt.title('Anzahl Kunden pro Tageszeit')\n",
    "plt.xlabel('Tageszeit')\n",
    "plt.ylabel('Anzahl Kunden')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "hft_ml",
   "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.11.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
