{
 "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": 3,
   "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 für 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": 4,
   "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 für 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": 12,
   "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 für 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": 10,
   "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 für 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()"
   ]
  }
 ],
 "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
}
