{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Data Streams Management – Transformationsoperatoren: Aufgaben\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from isda_streaming.data_stream import DataStream\n",
    "import random\n",
    "\n",
    "random.seed(84)  # wird benötigt, um bei allen die gleichen zufälligen Zahlen zu generieren"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Aufgabe 1\n",
    "\n",
    "Es soll ein Datenstrom initialisiert werden, der 10 zufällige Ganze Zahlen aus im Intervall [-10,10] enthält. \n",
    "\n",
    "Dafür soll die Funktion *random.randint(startwert, stoppwert)* genutzt werden, welche eine eine zufällige Zahl aus dem Intervall [startwert, stoppwert] generiert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Your code here\n",
    "ds = DataStream()\n",
    "\n",
    "print(ds)\n",
    "\n",
    "# wird benötigt um das Ergebnis mit dem erwarteten Ergebnis zu vergleichen\n",
    "result_ds = DataStream().from_collection([-1, -9, 5, -10, 6, 0, -4, 4, 5, 7])\n",
    "print(\"Does the result match the expected one?\", ds == result_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Aufgabe 2\n",
    "\n",
    "Ersetzen Sie jede 0 im Datenstrom durch -1 und 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ds = DataStream().from_collection([-1, -9, 5, -10, 6, 0, -4, 4, 5, 7])\n",
    "\n",
    "# Your code here\n",
    "replace_zero_ds = ds\n",
    "\n",
    "print(replace_zero_ds)\n",
    "\n",
    "# wird benötigt um das Ergebnis mit dem erwarteten Ergebnis zu vergleichen\n",
    "result_ds = DataStream().from_collection([-1, -9, 5, -10, 6, -1, 1, -4, 4, 5, 7])\n",
    "print(\"Does the result match the expected one?\", replace_zero_ds == result_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Aufgabe 3\n",
    "\n",
    "Erstellen Sie aus dem gegebenen Datenstrom zwei neue Datenströme, wobei der erste Datenstrom alle *geraden* ganzen Zahlen beinhaltet und der andere alle *ungeraden*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ds = DataStream().from_collection([-1, -9, 5, -10, 6, -1, 1, -4, 4, 5, 7])\n",
    "\n",
    "# Your code here\n",
    "even_ds = ds\n",
    "odd_ds = ds\n",
    "\n",
    "print(\"Datastream with even numbers:\", even_ds)\n",
    "print(\"Datastream with odd numbers:\", odd_ds)\n",
    "\n",
    "# wird benötigt um das Ergebnis mit dem erwarteten Ergebnis zu vergleichen\n",
    "result_ds = DataStream().from_collection([-10, 6, -4, 4])\n",
    "print(\"Does the even datastream match the expected one?\", even_ds == result_ds)\n",
    "\n",
    "result_ds = DataStream().from_collection([-1, -9, 5, -1, 1, 5, 7])\n",
    "print(\"Does the odd datastream match the expected one?\", odd_ds == result_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Aufgabe 4\n",
    "\n",
    "Kategorisieren Sie die Werte des Datenstroms. Ersetzen Sie dabei alle atomaren Werte des Datenstroms mit einem Tupel. Dabei gibt das erste Feld des Tuples an ob der Wert positiv ('p') oder negativ ('n') ist und das zweite Feld beinhaltet nur noch den absoluten Betrag des ursprünglichen Wertes. \n",
    "\n",
    "**Beispiel:**  \n",
    "Input-Stream = [2, -4, 6]  \n",
    "Output-Stream = [('p', 2), ('n', 4), ('p', 6)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "even_ds = DataStream().from_collection([-10, 6, -4, 4])\n",
    "odd_ds = DataStream().from_collection([-1, -9, 5, -1, 1, 5, 7])\n",
    "\n",
    "# Your code here\n",
    "even_tuple_ds = even_ds\n",
    "odd_tuple_ds = odd_ds\n",
    "\n",
    "print(\"even_tuple_ds = \", even_tuple_ds)\n",
    "print(\"odd_tuple_ds = \", odd_tuple_ds)\n",
    "\n",
    "# wird benötigt um das Ergebnis mit dem erwarteten Ergebnis zu vergleichen\n",
    "result_ds = DataStream().from_collection([(\"n\", 10), (\"p\", 6), (\"n\", 4), (\"p\", 4)])\n",
    "print(\n",
    "    \"Does the even datastream with tuples match the expected one?\",\n",
    "    even_tuple_ds == result_ds,\n",
    ")\n",
    "\n",
    "result_ds = DataStream().from_collection(\n",
    "    [(\"n\", 1), (\"n\", 9), (\"p\", 5), (\"n\", 1), (\"p\", 1), (\"p\", 5), (\"p\", 7)]\n",
    ")\n",
    "print(\n",
    "    \"Does the odd datastream with tuples match the expected one?\",\n",
    "    odd_tuple_ds == result_ds,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Aufgabe 5\n",
    "\n",
    "Bauen Sie nun eine **Dataflow-Pipeline**, welche die Ergebnisse der vorherigen Aufgaben kombiniert: \n",
    "\n",
    "Ersetzen Sie zunächst alle 0 Einträge im Datenstrom mit -1 und 1. Filtern Sie danach alle gerade Zahlen heraus um die übrigen Werte dann zu kategorisieren. Positive Werte sollen dabei erneut als Tupel mit 'p' kategorisiert werden und nur noch den absoluten Wert (zweites Feld) haben. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ds = DataStream().from_collection([-1, -9, 5, -10, 6, 0, -4, 4, 5, 7])\n",
    "\n",
    "# Your code here\n",
    "transformed_ds = ds\n",
    "\n",
    "print(transformed_ds)\n",
    "\n",
    "# wird benötigt um das Ergebnis mit dem erwarteten Ergebnis zu vergleichen\n",
    "result_ds = DataStream().from_collection(\n",
    "    [(\"n\", 1), (\"n\", 9), (\"p\", 5), (\"n\", 1), (\"p\", 1), (\"p\", 5), (\"p\", 7)]\n",
    ")\n",
    "print(\n",
    "    \"Does the odd datastream with tuples match the expected one?\",\n",
    "    transformed_ds == result_ds,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Aufgabe 6: Bluthochdruck\n",
    "Es steht ein Datenstrom zur Verfügung, der Informationen über den Blutdruck und den Puls eines Menschen beinhaltet. Unsere Sensoren messen dabei:\n",
    "- die Anzahl der **Herzschläge pro 10 Sekunden** und\n",
    "- den **Blutdruck in Pascal**, welcher zwei Werte annehmen kann:\n",
    "    - den systolischen Wert (wenn das Herz Blut in die Gefäße pumpt und sich zusammenzieht)\n",
    "    - den diastolischen Wert (wenn der Herzmuskel erschlafft)\n",
    "\n",
    "Weiterhin wissen wir, dass bei einem gesunden Erwachsenen:\n",
    "- Der Ruhepuls ungefähr zwischen **60 und 90 Schlägen pro Minute**,\n",
    "- der systolische Wert zwischen **110 und 130 mmHg** und\n",
    "- der diastolische Wert zwischen **80 und 90 mmHg** liegt.  \n",
    "\n",
    "Leider liefern uns die Sensoren die Daten über Puls und Blutdruck in einem schlechten Format.  \n",
    "- Der Blutdruck wird üblicherweise in mmHg (Millimeter Quecksilbersäulen) angegeben, **1 mmHg** entspricht dabei ungefähr **133,3 Pascal**.   \n",
    "- Der Puls entspricht in der Regel den **Herzschlägen pro Minute**, hier jedoch erfolgt die Messung pro 10s.\n",
    "\n",
    "Die Daten aus dem Datenstrom sollen zuerst in das herkömmliche Format transformiert werden und danach soll jeder Wert eine der folgenden Kategorien bekommen:\n",
    "- **\"puls\"** für Puls-Werte im gesunden Rahmen\n",
    "- **\"sys\"** für systolische Werte im gesunden Rahmen\n",
    "- **\"dia\"** für diastolische Werte im gesunden Rahmen\n",
    "- **\"anomaly\"** für Blutdruck-Werte, die höher als 130mmHg sind\n",
    "- **\"error\"** für sonstige Werte\n",
    "\n",
    "Da der beobachtete Patient an Bluthochdruck leidet, soll der Datenstrom nur noch den Durchschnitt aller bisher gesehenen Blutdruckwerte enthalten, die über 130mmHg liegen.  \n",
    "Anhand dieses Datenstroms könnte man nun Alarm schlagen, wenn der Durchschnitt auf einen zu hohen Wert ansteigt.\n",
    "\n",
    "**Hinweis:** Kategorisieren Sie zunächst die Daten, ansonsten kann es zu Überschneidungen bei den Wertebereichen kommen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "random.seed(42)\n",
    "data = [random.randint(10, 15) for _ in range(100)]\n",
    "data.extend(\n",
    "    [random.randint(14663, 17329) for _ in range(100)]\n",
    "    + [random.randint(17329, 21328) for _ in range(20)]\n",
    ")\n",
    "data.extend([random.randint(10664, 11997) for _ in range(100)])\n",
    "\n",
    "random.shuffle(data)\n",
    "\n",
    "ds = DataStream().from_collection(data)\n",
    "\n",
    "# 1) transform the measurements into the common format and assigns them a category\n",
    "categorized_ds = ds\n",
    "\n",
    "# comparison with expected result\n",
    "result_ds = DataStream().from_csv(\"../resources/09_data_streams/blutwerte_1.csv\")\n",
    "print(\n",
    "    \"Does the categorized datastream match the expected one?\",\n",
    "    categorized_ds == result_ds,\n",
    ")\n",
    "\n",
    "# 2) filter the anomaly data\n",
    "filtered_ds = ds\n",
    "\n",
    "# comparison with expected result\n",
    "result_ds = DataStream().from_csv(\"../resources/09_data_streams/blutwerte_2.csv\")\n",
    "print(\"Does the filtered datastream match the expected one?\", filtered_ds == result_ds)\n",
    "\n",
    "# 3) calculate the average\n",
    "avg_ds = ds\n",
    "\n",
    "# comparison with expected result\n",
    "result_ds = DataStream().from_csv(\"../resources/09_data_streams/blutwerte_3.csv\")\n",
    "print(\n",
    "    \"Does the datastream with the average values match the expected one?\",\n",
    "    avg_ds == result_ds,\n",
    ")\n",
    "\n",
    "# print the latest average value in the datastream\n",
    "last_avg = list(avg_ds)[-1]\n",
    "print(\"The average value of all seen anomalies is\", round(last_avg, 2))"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 4
}