From 3d2291d61909e3b692cec2cd88868d026e67491b Mon Sep 17 00:00:00 2001 From: DerGrumpf Date: Thu, 21 Nov 2024 17:56:00 +0100 Subject: [PATCH] Added Distribution --- .obsidian/workspace.json | 92 +- Gruppen/Engineering 1.md | 2 +- Gruppen/MeWi 2.md | 4 +- Gruppen/MeWi 3.md | 14 +- Gruppen/MeWi 6.md | 14 +- Gruppen/MeWi 7 (DiKum).md | 2 +- Lectures/06 22.11.2024.md | 345 ++++- ...l => 3.Extended_Applications_Lösungen.html} | 0 Material/Untitled.ipynb | 122 ++ .../lernmaterial/4.NumPy_MatPlotLib.ipynb | 10 +- .../wise_24_25/lernmaterial/5.SciPy.ipynb | 1230 +++++++++++++++++ To Do.md | 4 - 12 files changed, 1751 insertions(+), 88 deletions(-) rename Material/{3.Lösungen_Extended_Applications.slides.html => 3.Extended_Applications_Lösungen.html} (100%) create mode 100644 Material/Untitled.ipynb create mode 100644 Material/wise_24_25/lernmaterial/5.SciPy.ipynb diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json index 38f1f6b..7495b32 100644 --- a/.obsidian/workspace.json +++ b/.obsidian/workspace.json @@ -55,44 +55,16 @@ "state": { "type": "markdown", "state": { - "file": "Gruppen/MeWi 1.md", + "file": "Lectures/06 22.11.2024.md", "mode": "source", "source": false }, "icon": "lucide-file", - "title": "MeWi 1" - } - }, - { - "id": "d4d973e0d0e2e072", - "type": "leaf", - "state": { - "type": "markdown", - "state": { - "file": "Gruppen/MeWi 2.md", - "mode": "source", - "source": false - }, - "icon": "lucide-file", - "title": "MeWi 2" - } - }, - { - "id": "91b08793b1132c55", - "type": "leaf", - "state": { - "type": "markdown", - "state": { - "file": "Lectures/05 15.11.2024.md", - "mode": "source", - "source": false - }, - "icon": "lucide-file", - "title": "05 15.11.2024" + "title": "06 22.11.2024" } } ], - "currentTab": 5 + "currentTab": 3 } ], "direction": "vertical" @@ -210,10 +182,10 @@ "state": { "type": "outline", "state": { - "file": "Lectures/17 21.02.2025.md" + "file": "Lectures/06 22.11.2024.md" }, "icon": "lucide-list", - "title": "Outline of 17 21.02.2025" + "title": "Outline of 06 22.11.2024" } }, { @@ -255,19 +227,33 @@ "table-editor-obsidian:Advanced Tables Toolbar": false } }, - "active": "91b08793b1132c55", + "active": "91e68fc77697e0f9", "lastOpenFiles": [ - "Material/3.Lösungen_Extended_Applications.slides.html", - "Material/wise_24_25/Folien/3.Lösungen_Extended_Applications.ipynb", - "Material/wise_24_25/Folien/Untitled.ipynb", - "Material/wise_24_25/Folien", - "Material/wise_24_25/lernmaterial/4.NumPy_MatPlotLib.ipynb", - "Material/wise_24_25/lernmaterial/3.Extended_Applications.ipynb", - "Material/wise_24_25/lernmaterial/2.Tutorial.ipynb", - "Material/wise_24_25/lernmaterial/1.Tutorial.ipynb", - "Material/wise_24_25/3.Extended_Applications.ipynb", - "Material/wise_24_25/2.Tutorial.ipynb", - "Material/wise_24_25/1.Tutorial.ipynb", + "Lectures/05 15.11.2024.md", + "Gruppen/MeWi 1.md", + "Lectures/27.11.2024.md", + "Lectures/06 22.11.2024.md", + "Material/wise_24_25/lernmaterial/5.SciPy.ipynb", + "Material/wise_24_25/lernmaterial/Untitled.ipynb", + "Material/Untitled.ipynb", + "Timetable.md", + "Lectures/16 14.02.2025.md", + "Lectures/17 21.02.2025.md", + "To Do.md", + "Gruppen/Engineering 1.md", + "Gruppen/MeWi 7 (DiKum).md", + "Gruppen/MeWi 6.md", + "Gruppen/MeWi 5.md", + "Gruppen/MeWi 4.md", + "Gruppen/MeWi 3.md", + "Gruppen/MeWi 2.md", + "Material/3.Extended_Applications_Lösungen.html", + "Material/3.Lösungen_Extended_Applications.html", + "Material/wise_24_25/lernmaterial/2.Tutorial_2.ipynb", + "Material/wise_24_25/lernmaterial/1.Tutorial_1.ipynb", + "Material/testfile.txt", + "Material/V4.ipynb", + "Material/Tutorial2_Lösungen.ipynb", "Material/env/lib/python3.12/site-packages/matplotlib/mpl-data/sample_data/logo2.png", "Material/env/lib/python3.12/site-packages/matplotlib/mpl-data/sample_data/grace_hopper.jpg", "Material/env/lib/python3.12/site-packages/matplotlib/mpl-data/sample_data/Minduka_Present_Blue_Pack.png", @@ -279,17 +265,6 @@ "Material/env/lib/python3.12/site-packages/matplotlib/mpl-data/images/subplots.svg", "Material/env/lib/python3.12/site-packages/matplotlib/mpl-data/images/subplots.png", "Lectures/04 08.11.2024.md", - "Gruppen/Engineering 1.md", - "Gruppen/MeWi 4.md", - "Gruppen/MeWi 5.md", - "Gruppen/MeWi 3.md", - "Gruppen/MeWi 2.md", - "Gruppen/MeWi 1.md", - "Gruppen/MeWi 7 (DiKum).md", - "Gruppen/MeWi 6.md", - "To Do.md", - "Timetable.md", - "Lectures/17 21.02.2025.md", "Lectures/03 01.11.2024.md", "Lectures/02 25.10.2024.md", "README.md", @@ -299,9 +274,6 @@ "Material/README.md", "Material/ToDo.md", "Student List.md", - "Lectures/16 14.02.2025.md", - "Material/env/lib/python3.12/site-packages/nbgrader/server_extensions/formgrader/static/components/underscore/README.md", - "Material/env/lib/python3.12/site-packages/nbgrader/server_extensions/formgrader/static/components/jquery-color/README.md", - "Material/env/lib/python3.12/site-packages/nbgrader/server_extensions/formgrader/static/components/jquery/README.md" + "Material/env/lib/python3.12/site-packages/nbgrader/server_extensions/formgrader/static/components/underscore/README.md" ] } \ No newline at end of file diff --git a/Gruppen/Engineering 1.md b/Gruppen/Engineering 1.md index c6a7c7b..fb1ee32 100644 --- a/Gruppen/Engineering 1.md +++ b/Gruppen/Engineering 1.md @@ -10,7 +10,7 @@ tags: | Name | Punkte | Durchschnitt | Jupyter Kennung | Mail | | -------------- | ------ | ------------ | -------------------------------- | ------------------------------------------------------------------------- | | Janna Heiny | | | 3140c4b62381a2203803f8b237118244 | [j.heiny@tu-braunschweig.de](mailto:j.heiny@tu-braunschweig.de) | -| Milena Krieger | | | 8be9a4cc0b240a18171892b873dc2cb8 | [m.krieger@tu-braunschweig.de](mailto:m.krieger@tu-braunschweig.de) | +| Milena Krieger | 30 | | 8be9a4cc0b240a18171892b873dc2cb8 | [m.krieger@tu-braunschweig.de](mailto:m.krieger@tu-braunschweig.de) | | Xiaowei Wang | | | 39dc5bd7686c3280247aacee82c9818e | [xiaowei.wang@tu-braunschweig.de](mailto:xiaowei.wang@tu-braunschweig.de) | | | | | | | | | | | | | diff --git a/Gruppen/MeWi 2.md b/Gruppen/MeWi 2.md index 1768e09..67e3021 100644 --- a/Gruppen/MeWi 2.md +++ b/Gruppen/MeWi 2.md @@ -12,8 +12,8 @@ tags: | Izabel Mike | 29.5 | | 8c710a24debf6159659d1e58dd975ce2 | [i.mike@tu-braunschweig.de](mailto:i.mike@tu-braunschweig.de) | | Lara Troschke | 20.5 | | 7b441c67713f2a49811625905612f19b | [l.troschke@tu-braunschweig.de](mailto:l.troschke@tu-braunschweig.de) | | Inga-Brit Turschner | 25.5 | | 72f0b5fd2cdf4dd808ca9a3add584c75 | [i.turschner@tu-braunschweig.de](mailto:i.turschner@tu-braunschweig.de) | -| Yannik Haupt | | | f4f597c57d8a31960750e0647f917ed3 | | -| | | | | | +| Yannik Haupt | | | f4f597c57d8a31960750e0647f917ed3 | [y.haupt@tu-braunschweig.de](mailto:y.haupt@tu-braunschweig.de) | +| Aurela Brahimi | | | 5ce6c08f9b055ca085232da514623ca4 | [a.brahimi@tu-braunschweig.de](mailto:a.brahimi@tu-braunschweig.de) | # Notizen diff --git a/Gruppen/MeWi 3.md b/Gruppen/MeWi 3.md index e468115..e113b1a 100644 --- a/Gruppen/MeWi 3.md +++ b/Gruppen/MeWi 3.md @@ -7,13 +7,13 @@ tags: --- # Mitglieder -| Name | Punkte | Durchschnitt | Jupyter Kennung | Mail | -| ----------------- | ------ | ------------ | --------------- | ----------------------------------------------------------------------------- | -| Fabian Rothberger | | | | [f.rothberger@tu-braunschweig.de](mailto:f.rothberger@tu-braunschweig.de) | -| Flemming Schur | | | | [flemming.schur@tu-braunschweig.de](mailto:flemming.schur@tu-braunschweig.de) | -| Josefine Sinkemat | | | | [j.sinkemat@tu-braunschweig.de](mailto:j.sinkemat@tu-braunschweig.de) | -| | | | | | -| | | | | | +| Name | Punkte | Durchschnitt | Jupyter Kennung | Mail | +| ----------------- | ------ | ------------ | -------------------------------- | ----------------------------------------------------------------------------- | +| Fabian Rothberger | | | | [f.rothberger@tu-braunschweig.de](mailto:f.rothberger@tu-braunschweig.de) | +| Flemming Schur | | | df2b997f3ff3e1f7395fb071bb6c9f17 | [flemming.schur@tu-braunschweig.de](mailto:flemming.schur@tu-braunschweig.de) | +| Josefine Sinkemat | | | | [j.sinkemat@tu-braunschweig.de](mailto:j.sinkemat@tu-braunschweig.de) | +| | | | | | +| | | | | | # Notizen diff --git a/Gruppen/MeWi 6.md b/Gruppen/MeWi 6.md index 5089bc8..09b8a8b 100644 --- a/Gruppen/MeWi 6.md +++ b/Gruppen/MeWi 6.md @@ -7,13 +7,13 @@ tags: --- # Mitglieder -| Name | Punkte | Durchschnitt | Jupyter Kennung | Mail | -| --------------- | ------ | ------------ | -------------------------------- | ----------------------------------------------------------------------- | -| Nele Grundke | | | f61621cbe911f21ddd781c21e4528b07 | [n.grundke@tu-braunschweig.de](mailto:n.grundke@tu-braunschweig.de) | -| Julia Limbach | | | | [j.limbach@tu-braunschweig.de](mailto:j.limbach@tu-braunschweig.de) | -| Melina Sablotny | | | 4111400b4ae2c863a1c4b73a21f87093 | [m.sablotny@tu-braunschweig.de](mailto:m.sablotny@tu-braunschweig.de) | -| Lucy Thiele | | | 4c0ddab5bed6ff025cee04f8d73301a3 | [lucy.thiele@tu-braunschweig.de](mailto:lucy.thiele@tu-braunschweig.de) | -| | | | | | +| Name | Punkte | Durchschnitt | Jupyter Kennung | Mail | +| ---------------- | ------ | ------------ | -------------------------------- | ----------------------------------------------------------------------- | +| Nele Grundke | | | f61621cbe911f21ddd781c21e4528b07 | [n.grundke@tu-braunschweig.de](mailto:n.grundke@tu-braunschweig.de) | +| Julia Limbach | | | 2f7f31211275384791a1799cd95750bf | [j.limbach@tu-braunschweig.de](mailto:j.limbach@tu-braunschweig.de) | +| Melina Sablotny | | | 4111400b4ae2c863a1c4b73a21f87093 | [m.sablotny@tu-braunschweig.de](mailto:m.sablotny@tu-braunschweig.de) | +| Lucy Thiele | | | 4c0ddab5bed6ff025cee04f8d73301a3 | [lucy.thiele@tu-braunschweig.de](mailto:lucy.thiele@tu-braunschweig.de) | +| Marleen, Adolphi | | | bb549f9016ee05a07ce271c10482879d | [m.adolphi@tu-braunschweig.de](mailto:m.adolphi@tu-braunschweig.de) | # Notizen diff --git a/Gruppen/MeWi 7 (DiKum).md b/Gruppen/MeWi 7 (DiKum).md index 7fd470c..51e9079 100644 --- a/Gruppen/MeWi 7 (DiKum).md +++ b/Gruppen/MeWi 7 (DiKum).md @@ -10,7 +10,7 @@ tags: | Name | Punkte | Durchschnitt | Jupyter Kennung | Mail | | ------------------- | ------ | ------------ | -------------------------------- | --------------------------------------------------------------------------------- | | Abdalaziz Abunjaila | 30.5 | | 79b388885f89954decaefc9e19aa8871 | [a.abunjaila@tu-braunschweig.de](mailto:a.abunjaila@tu-braunschweig.de) | -| Marleen Adolphi | | | bb549f9016ee05a07ce271c10482879d | [m.adolphi@tu-braunschweig.de](mailto:m.adolphi@tu-braunschweig.de) | +| | | | | | | Alea Schleier | | | beb3bcd7515400b58f6fab7567193cbf | [a.schleier@tu-braunschweig.de](mailto:a.schleier@tu-braunschweig.de) | | Marie Seeger | | | f7017b11a2904a74302c9f4f217779fb | [marie.seeger@tu-braunschweig.de](mailto:marie.seeger@tu-braunschweig.de) | | Lilly-Lu Warnken | | | 5fe894b59ff39da82ac4361dcb2d35b8 | [lilly-lu.warnken@tu-braunschweig.de](mailto:lilly-lu.warnken@tu-braunschweig.de) | diff --git a/Lectures/06 22.11.2024.md b/Lectures/06 22.11.2024.md index 9e30d3a..1471ab5 100644 --- a/Lectures/06 22.11.2024.md +++ b/Lectures/06 22.11.2024.md @@ -9,4 +9,347 @@ tags: - [ ] Bernoulli Distributions - [ ] Binomial Distributions -- [ ] Normal Distributions \ No newline at end of file +- [ ] Normal Distributions +- [ ] Regression + +## Aufgabe - Erster eigener Plot Square Root + +Analog zu voheriger Erklärung plotten Sie im folgenden die Funktion Square Root, Mathematisch definiert als $f(x) = \sqrt x; \quad x \geq 0$. + +Gehen Sie dabei wie folgt vor: + +1. Definieren Sie einen **geeigneten** [Linespace](https://numpy.org/doc/stable/reference/generated/numpy.linspace.html#numpy-linspace) für die Zahlenraum 0...100. (Tipp: Achten Sie auf die Definition! Die Wurzel ist nur für positive Zahlen definiert.) +2. Berechnen Sie mittels der Funktion [np.sqrt](https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html#numpy.sqrt) die Werte für die Wurzel. +3. Plotten Sie das Ergebnis + +```python +import numpy as np +import matplotlib.pyplot as plt + +# geeigneter Linespace für den Zahlenraum 0 bis 100 +x = np.linspace (0, 100, 500) # 500 Punkte für eine glatte Darstellung + +# Berechnen der Wurzelfunktion +y = np.sqrt(x) + +# plotten der Ergebnisse +plt.plot(x, y, label="f(x)= √x") +plt.title("Plot der Wurzelfunktion") +plt.xlabel("x") +plt.ylabel("f(x)") +plt.grid(True) +plt.legend() +plt.show() +``` +Alea Schleier + + +## Aufgabe[¶](https://jupyter2.ifn.ing.tu-bs.de:8000/user/instructor-einfhrung-in-die-prog/formgrader/submissions/14fa26f422cf4db2a97309e97b0bfdbd/?index=16#Aufgabe) + +_6 Punkte_ + +Plote die Zufallszahlen eines _Permuted Congruent Generators_ mittels NumPy & MatPlotLib. + +- Gegeben ist der Anfangszustand des Generators. +- Nutze die Dokumentation und rufe den `default_rng` aus dem `numpy.random` Modul, **20** mal auf speichere die Werte in der variablen `pcgs`. _(Tipp: Nutze ein NumPy Array)_ +- Sortiere im nächsten Schritt die in `pcgs` gespeicherten Werte und speichere diese in `pcgs_sorted` +- Plotte sinnvoll beide Array. Gestalte den Plot angemessen. + +```python +import numpy as np # Import NumPy +import matplotlib.pyplot as plt # Import Matplotlib for plotting + +# 1. Setting the random seed +np.random.seed(42) + +# 2. Generate 20 random numbers using the default_rng generator +rng = np.random.default_rng() # Initialize the default random number generator +pcgs = rng.random(20) # Generate 20 random numbers + +# 3. Sort the generated numbers and store them in pcgs_sorted +pcgs_sorted = np.sort(pcgs) # Sort the numbers + +# 4. Print the generated arrays for verification +print("PCGs:", pcgs) +print("Sorted PCGs:", pcgs_sorted) + +# 5. Plot both arrays +plt.figure(figsize=(8, 6)) +plt.plot(pcgs, label='PCGs (Unsorted)', linestyle='dashed', marker='o') +plt.plot(pcgs_sorted, label='PCGs (Sorted)', linestyle='solid', marker='x') +plt.title('Permuted Congruent Generator: Unsorted vs Sorted') +plt.xlabel('Index') +plt.ylabel('Value') +plt.legend() +plt.grid(True) +plt.show() +``` +Abdalaziz Abunjaila + +```python +np.random.seed(42) # Setting a fixed start Value for the Generator +pcgs: np.array = None +pcgs_sorted: np.array = None + +#mycode +import numpy as np +import matplotlib.pyplot as plt + +rng = np.random.default_rng(seed=42) + +pcgs = np.array([rng.random() for _ in range(20)]) + +pcgs_sorted = np.sort(pcgs) + +plt.figure(figsize=(10, 5)) + +plt.plot(pcgs, label="PCG Zufallszahlen", color='blue', marker='o', linestyle='--') + +plt.plot(pcgs_sorted, label="Sortierte PCG Zufallszahlen", color='green', marker='x', linestyle='-') + +plt.title("PCG Zufallszahlen und sortierte PCG Zufallszahlen") +plt.xlabel("Index") +plt.ylabel("Wert") +plt.legend() + +plt.show() +``` +Donika Nuhiu + +```python +np.random.seed(42) # Setting a fixed start Value for the Generator +pcgs: np.array = None +pcgs_sorted: np.array = None + +import numpy as np +import matplotlib.pyplot as plt + +# Erstellen des Zufallsgenerators und Generation von 20 Zufallszahlen +rng = np.random.default_rng() # Initialisiere den Permuted Congruent Generator +pcgs = rng.random(20) # 20 Zufallszahlen erzeugen und in ein NumPy Array speichern + +# Sortieren der Zufallszahlen +pcgs_sorted = np.sort(pcgs) + +# Plotten der Ergebnisse +plt.figure(figsize=(10, 6)) + +# Original Zufallszahlen +plt.plot(pcgs, marker='o', linestyle='-', color='blue', label='Original-Zufallszahlen') + +# Sortierte Zufallszahlen +plt.plot(pcgs_sorted, marker='x', linestyle='--', color='red', label='Sortierte Zufallszahlen') + +# Gestalte den Plot +plt.title("Vergleich: Original- und sortierte Zufallszahlen") +plt.xlabel("Index") +plt.ylabel("Zufallswert") +plt.grid(True) +plt.legend() + +plt.show() +``` +Alea Schleier + +```python +np.random.seed(42) # Setting a fixed start Value for the Generator +pcgs: np.array = None +pcgs_sorted: np.array = None + +# YOUR CODE HERE +rng = np.random.default_rng(42) +pcgs = rng.random(20) +pcgs_sorted = np.sort(pcgs) + +x = np.linspace(0, 20, num=20) + +plt.plot(x, pcgs, color='c', label='Zufallszahlen') +plt.plot(x, pcgs_sorted, color='b', label='Zufallszahlen (sortiert)') + +plt.title('Zufallszahlen eines PCG') +plt.xlabel('Index') +plt.ylabel('Wert') + +plt.xlim(0, 20) +plt.ylim(0, 1.25) +plt.xticks(np.arange(0, 20, step=3)) +plt.yticks(np.arange(0, 1.25, step=0.2)) + +mean_value = np.mean(pcgs) +plt.axhline(y=mean_value, color='r', linestyle="dashed", label=f'Durchschnitt: {mean_value:.2f}') + +plt.legend() +plt.show() +``` +Nova Eib + +```python +np.random.seed(42) # Setting a fixed start Value for the Generator +pcgs: np.array = None +pcgs_sorted: np.array = None + +# YOUR CODE HERE +import numpy as np +import matplotlib.pyplot as plt + +rng = np.random.default_rng(seed=42) + +pcgs = rng.random(20) + +pcgs_sorted = np.sort(pcgs) + +plt.figure(figsize=(10, 6)) + +plt.plot(pcgs, 'o-', label='Unsortiert') + +plt.plot(pcgs_sorted, 's-', label='Sortiert') + +plt.title('Zufallszahlen eines Permuted Congruent Generators') +plt.xlabel('Index') +plt.ylabel('Wert') +plt.grid(True) +plt.legend() + +plt.show() +``` +Izabel Mike + +### Aufgabe[¶](https://jupyter2.ifn.ing.tu-bs.de:8000/user/instructor-einfhrung-in-die-prog/formgrader/submissions/f483499addec4dd8886a0ee278677732/?index=21#Aufgabe) + +_5 Punkte_ + +Ihnen ist ein Datenset `sec_school` einer Hauptschule gegeben, welches die Klassenstufen von 5 bis 9 auf die Anzahl ihrer Schüler im Jahrgang mappt. + +Definieren Sie einen Barplot. Gehen Sie dabei wie folgt vor: + +1. Definieren Sie ein geeignetes Farbschema zur Darstellung der Daten. +2. Extrahieren Sie die Schlüssel und Werte aus dem Datenset und übergeben Sie diese zusammen mit den Farbwerten an die Funktion `plt.bar`. +3. Setzen Sie geeignete Werte für die X & Y-Achse. +4. Setzen Sie einen geeigneten Titel für den Plot. +5. Plotten Sie den Werte + +```python +import matplotlib.pyplot as plt + +sec_school = { + '5. Klasse': 29, + '6. Klasse': 35, + '7. Klasse': 25, + '8. Klasse': 28, + '9. Klasse': 31 +} + +bar_colors = ["purple", "blue", "green", "orange", "red"] + +plt.bar(sec_school.keys(), sec_school.values(), color=bar_colors) + +plt.xlabel("Klassenstufen") +plt.ylabel("Anzahl Schüler") +plt.title("Anzahl der Schüler pro Klassenstufe in der Hauptschule") + +plt.show() +``` +Donika Nuhiu + +```python +import matplotlib.pyplot as plt + +sec_school = { + '5. Klasse': 29, + '6. Klasse': 35, + '7. Klasse': 25, + '8. Klasse': 28, + '9. Klasse': 31 +} + +colors = ['blue', 'green', 'orange', 'purple', 'red'] + +grades = list(sec_school.keys()) # Klassenstufen +students= list(sec_school.values()) # Schüleranzahl + +plt.bar (grades, students, color=colors) + +plt.xlabel("Klassenstufen") +plt.ylabel("Anzahl der Schüler") + +plt.title("Schüleranzahl pro Klassenstufe in der Hauptschule") + +plt.grid(axis='y', linestyle='--', alpha=0.7) # Gitterlinie zur besseren Lesbarkeit +plt.show() +``` +Alea Schleier + +```python +bar_colors = ["red", "orangered", "darkorange", "orange", "gold"] + +plt.bar(sec_school.keys(), sec_school.values(), color=bar_colors) + +plt.title("Klassenverteilung (Hauptschule)") +plt.ylabel("Anzahl Kinder") +plt.xlabel("Klassenstufen") + +# Ich finde die Werte der x- und y-Achse schon passend, also mach mich wenn dann für meine Fehleinschätzung und nicht für meinen Analphabetismus fertig, ich habe den Punkt gelesen, danke + +mean_value = np.mean(list(sec_school.values())) +plt.axhline(y=mean_value, color='blue', linestyle="dashed", label=f'Durchschnitt: {mean_value:.2f}') + +plt.legend() +plt.show() +``` +Nova Eib +## Aufgabe[¶](https://jupyter2.ifn.ing.tu-bs.de:8000/user/instructor-einfhrung-in-die-prog/formgrader/submissions/a02d96d8a5c8452b91ac790b5fb5ce9b/?index=24#Aufgabe) + +_5 Punkte_ + +Ihnen ist ein Datenset `sec_school` einer Hauptschule gegeben, welches die Klassenstufen von 5 bis 9 auf die Anzahl ihrer Schüler im Jahrgang mappt. + +Definieren Sie einen Pieplot. Gehen Sie dabei wie folgt vor: + +1. Definieren Sie ein geeignetes Farbschema zur Darstellung der Daten. +2. Extrahieren Sie die Schlüssel und Werte aus dem Datenset und übergeben Sie diese zusammen mit den Farbwerten an die Funktion `plt.pie`. (Nutzen Sie zum Anzeigen der Prozentwerte) +3. Lassen Sie die 6. Klasse 25% und die 9. Klasse 40% explodieren. +4. Setzen Sie einen geeigneten Titel für den Plot. +5. Plotten Sie den Werte. + +```python +import matplotlib.pyplot as plt + +#geeignetes Farbschema definieren, Kontrastreiche Farben zur einfachen Unterscheidung +colors = ['#ff6f61', '#6b5b95', '#88b04b', '#f7cac9', '#92a8d1'] + +#extrahieren der Werte und Schlüssel +keys = list (sec_school.keys()) +values = list (sec_school.values()) + +#explodieren der 6. und 9. Klassenstufe +explode = [0, 0.25, 0, 0, 0.4] + +plt.pie(values, labels = keys, colors = colors, autopct = '%1.1f%%', startangle = 90, explode = explode) +plt.title ('Verteilung der Schüler*innen auf die unterschiedlichen Klassenstufen') +plt.axis ('equal') + +plt.show() +``` +Lara Troschke + +```python +pie_colors = ["red", "orangered", "darkorange", "orange", "gold"] + +plt.pie(sec_school.values(), labels=sec_school.keys(), autopct='%1.1f%%', explode=[0, 0.25, 0, 0, 0.4], colors=pie_colors) + +plt.title("Klassenverteilung (Hauptschule)") + +plt.show() +``` +Nova Eib + +```python +pie_colors = ["lightpink", "darkseagreen", "mistyrose", "cadetblue", "rosybrown"] + +plt.pie(sec_school.values(), labels=sec_school.keys(), autopct='%1.1f%%', explode=[0, 0.25, 0, 0, 0.4], colors=pie_colors) + +plt.title("Klassenverteilung einer Hauptschule") + +plt.show() +``` +Julia Limbach \ No newline at end of file diff --git a/Material/3.Lösungen_Extended_Applications.slides.html b/Material/3.Extended_Applications_Lösungen.html similarity index 100% rename from Material/3.Lösungen_Extended_Applications.slides.html rename to Material/3.Extended_Applications_Lösungen.html diff --git a/Material/Untitled.ipynb b/Material/Untitled.ipynb new file mode 100644 index 0000000..e8600fc --- /dev/null +++ b/Material/Untitled.ipynb @@ -0,0 +1,122 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d74e7711-ed1a-4749-8827-2e6fa5798d68", + "metadata": {}, + "outputs": [], + "source": [ + "def lcg (a,c,m, startwert):\n", + "\n", + " if a<=0 or c<0 or m<=0 or startwert <0:\n", + " return None #prüfung der werte \n", + " \n", + " x = startwert \n", + " while 1:\n", + " x=(a*x+c)%m\n", + " yield x " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2993ac89-2be8-4c61-a6e2-43a1008f2d36", + "metadata": {}, + "outputs": [], + "source": [ + "def lcg_test(seed: int, scalar: int, modulus: int, offset: int) -> int:\n", + " assert modulus > 0, \"Modulus must be greater than 0\"\n", + " assert 0 <= scalar and scalar < modulus, \"Scalar must be in range 0 <= a < m\"\n", + "\n", + " while seed > 1:\n", + " seed = (scalar*seed+offset) % modulus\n", + " assert seed >= 0\n", + " yield seed" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "02a21a6d-0892-44f0-b0fd-6e5f8fe83962", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lcg using Cocktailshaker Numbers: 3089810780120156248\n", + "Correct should be: 3089810780120156248\n", + "\n", + "Lcg using Cocktailshaker Numbers: 8356396685252565260\n", + "Correct should be: 8356396685252565260\n", + "\n", + "Lcg using Cocktailshaker Numbers: 1921117399837525548\n", + "Correct should be: 1921117399837525548\n", + "\n", + "Lcg using Cocktailshaker Numbers: 14806858147081821235\n", + "Correct should be: 14806858147081821235\n", + "\n", + "Lcg using Cocktailshaker Numbers: 2557599628047639428\n", + "Correct should be: 2557599628047639428\n", + "\n", + "Lcg using Cocktailshaker Numbers: 16453652254840064460\n", + "Correct should be: 16453652254840064460\n", + "\n", + "Lcg using Cocktailshaker Numbers: 15995401842808378843\n", + "Correct should be: 15995401842808378843\n", + "\n", + "Lcg using Cocktailshaker Numbers: 681272290641816305\n", + "Correct should be: 681272290641816305\n", + "\n", + "Lcg using Cocktailshaker Numbers: 10955466795170118648\n", + "Correct should be: 10955466795170118648\n", + "\n", + "Lcg using Cocktailshaker Numbers: 13714992071537968180\n", + "Correct should be: 13714992071537968180\n", + "\n" + ] + } + ], + "source": [ + "s = lcg(3203021881815356449, 11742185885288659963, 2**64-1, 3935559000370003845)\n", + "t = lcg_test(3935559000370003845, 3203021881815356449, 2**64-1, 11742185885288659963)\n", + "\n", + "for _ in range(10):\n", + " stud = next(s)\n", + " instructor = next(t)\n", + " print(\"Lcg using Cocktailshaker Numbers:\", stud)\n", + " print(\"Correct should be:\", instructor, end='\\n\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40aeb297-aeb5-4fca-8ae4-cb84c7f13957", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Material/wise_24_25/lernmaterial/4.NumPy_MatPlotLib.ipynb b/Material/wise_24_25/lernmaterial/4.NumPy_MatPlotLib.ipynb index 35e6c6f..7ae13b6 100644 --- a/Material/wise_24_25/lernmaterial/4.NumPy_MatPlotLib.ipynb +++ b/Material/wise_24_25/lernmaterial/4.NumPy_MatPlotLib.ipynb @@ -1707,13 +1707,13 @@ "id": "a2fbf6d5-9460-48bc-8183-b2afb9c5c186", "metadata": { "nbgrader": { - "grade": false, + "grade": true, "grade_id": "cell-9e88f0a0a4a77c47", - "locked": true, + "locked": false, "points": 3, "schema_version": 3, - "solution": false, - "task": true + "solution": true, + "task": false } }, "outputs": [ @@ -2784,7 +2784,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.5" + "version": "3.12.7" } }, "nbformat": 4, diff --git a/Material/wise_24_25/lernmaterial/5.SciPy.ipynb b/Material/wise_24_25/lernmaterial/5.SciPy.ipynb new file mode 100644 index 0000000..c1a727e --- /dev/null +++ b/Material/wise_24_25/lernmaterial/5.SciPy.ipynb @@ -0,0 +1,1230 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fd2f3bf7-b314-4449-95dc-f07d1a13f1c6", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-04300aa5f61f7f12", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "# 5. Programmierübung: SciPy\n", + "\n", + "
\n", + "
\n", + " Willkommen zur fünften Programmierübung Einführung in Python 3.\n", + "
\n", + " \n", + "
\n", + "\n", + "Wenn Sie Fragen oder Verbesserungsvorschläge zum Inhalt oder Struktur der Notebooks haben, dann können sie eine E-Mail an Phil Keier ([p.keier@hbk-bs.de](mailto:p.keier@hbk-bs.de?subject=[SigSys]%20Feedback%20Programmierübung&)) oder Martin Le ([martin.le@tu-bs.de](mailto:martin.le@tu-bs.de?subject=[SigSys]%20Feedback%20Programmierübung&)) schreiben.\n", + "\n", + "Link zu einem Python Spickzettel: [hier](https://s3.amazonaws.com/assets.datacamp.com/blog_assets/PythonForDataScience.pdf)\n", + "\n", + "Der Großteil des Python-Tutorials stammt aus der Veranstaltung _Deep Learning Lab_ und von [www.python-kurs.eu](https://www.python-kurs.eu/python3_kurs.php) und wurde für _Signale und Systeme_, sowie _Einführung in die Programmierung für Nicht Informatiker_ angepasst.\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "bb677cea-65c2-486d-9442-6495b5063bd2", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-110034393ecbe731", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "# Was ist SciPy\n", + "\n", + "SciPy steht für Scientific Python und ist eine Open-Source-Bibliothek, die auf der bewährten Architektur von NumPy aufbaut. Sie bietet eine Vielzahl von Funktionen, die speziell für ingenieurtechnische und wissenschaftliche Anwendungen entwickelt wurden. In diesem Zusammenhang möchten wir uns insbesondere mit Teilen des Statistikmoduls von SciPy vertraut machen.\n", + "\n", + "__Für dieses Notebook schauen Sie bitte in die [SciPy Docs](https://docs.scipy.org/doc/scipy/tutorial/index.html)!!!__ Dort sind alle Funktionen beschrieben die wir hier bearbeiten und noch mehr!\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "3dde4289-bc10-49fc-875d-ebc44fbf807a", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-82f61f58224c5db9", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "SciPys wird meist als `sp` importiert da für diese Aufgabe nur das Statistik modul nötig ist wird einfach dieses importiert. Aufgrund des kurzen schlüssigen namens findet keine umbenennung statt:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e058b67a-ab34-4685-b023-084bfa80f171", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-fe3ab9d39498717f", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "from scipy import stats" + ] + }, + { + "cell_type": "markdown", + "id": "57ada7f0-5eea-45cc-b8d0-85f52c7f6b55", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-eec41b75718f0e4e", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "5983dc91-91f3-4b6b-b6c2-9873b9ea8db9", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-65e8f06a2b373c8c", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "# Lineare Regression\n", + "\n", + "## Motivation\n", + "\n", + "Die **lineare Regression** ist eine grundlegende Methode zur Modellierung von Beziehungen zwischen Variablen. Sie hilft, Zusammenhänge zu verstehen und ermöglicht Vorhersagen auf Basis vorhandener Daten. Durch die Bestimmung einer linearen Beziehung zwischen einer abhängigen und einer oder mehreren unabhängigen Variablen können wir Trends identifizieren und zukünftige Werte schätzen. Ihre Einfachheit, Effizienz und die Möglichkeit, auch bei großen Datensätzen präzise Ergebnisse zu erzielen, machen sie zu einem wertvollen Werkzeug in der Datenanalyse und ein Fundament für komplexere Modelle.\n", + "\n", + "Dafür geht man davon aus, dass es zwei unabhängige Variablen $x_1$ & $x_2$ gibt, für die eine Zukünftige Aussage getätigt werden soll. Hierfür wird eine fehlerminimierte Gerade $g(x)$ zwischen die Datenpunkte gelegt. Daraus resultierenden lässt sich mit $g(x)$ eine zukünftige Vorhersage in einem bestimmten Fehlerbereich tätigen.\n", + "\n", + "Aus der Schule sollte die Geraden Gleichung $g(x) = m\\cdot x+b$ bekannt sein. Dabei beschreibt $m$ die Steigung (Slope) & $b$ den Schnittpunkt mit der y-Achse (interception). Die **lineare regression** bietet daher die Möglichkeit diese beiden Parameter herauszufinden.\n", + "\n", + "Für das folgende Beispiel werden zwei (pseudo-)zufällig erzeugte Datensets generiert, auf welche dann die lineare regression angewandt wird. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "60712a1d-7a55-44f4-89e9-cae5ceab952a", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-fbb9bfd35036d55e", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "rand = np.random.default_rng(42) # RNG with fixed seed\n", + "\n", + "# Generate, Scale, round and sort random numbers for an increasing slope\n", + "scalar: int = 10\n", + "x: np.array = np.round(np.sort(rand.random(20) * scalar), decimals=2)\n", + "y: np.array = np.round(np.sort(rand.random(20) * scalar), decimals=2)\n", + "\n", + "# Plot these values\n", + "plt.title(\"Scattered Random Values\")\n", + "plt.grid()\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "plt.scatter(x,y, color='g')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "083ba4ea-8e6f-4286-8049-1c8e3f22c004", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-caa85fe6a76214bf", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Aus den erzeugten Daten ist klar ersichtlich, dass diese einem Trend folgen. Mittels SciPy wollen wir diesen Trend darstellen.\n", + "\n", + "Dazu wird die Funktion `linregress` verwendet. Diese verlangt, wie aus der [Dokumentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.linregress.html#scipy.stats.linregress) zu entnehmen, zwei arrays mit Daten. \n", + "\n", + "Die Ausgabe ist aufgespalten in 5 Parameter:\n", + "- slope: die Steigung `m` der Geraden\n", + "- intercept: der Punkt an dem die Gerade die y-Achse trifft oder das `b`\n", + "- rvalue: der Pearson Korrelations Koefficient, welcher voerst ignoriert wird\n", + "- pvalue: der p-Wert das die Nullhypothese stimmt, wird auch ignoriert\n", + "- stderr: der Standard Error der Steigung, unter der Annahme einer Normalverteilung der Daten *(PCGs sind Normalverteilt)*" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "9c1959d8-5bac-45fa-9aa2-47fa79943d72", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-553a583b633273d5", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "slope, intercept, _, _, stderr = stats.linregress(x,y)" + ] + }, + { + "cell_type": "markdown", + "id": "2c2bd060-bb4c-440f-9a04-72382c9a33eb", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-111845c39238eeee", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Aus `slope` & `intercept` lässt sich folglich eine Gerade definieren:" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "1e30868c-f11f-43bd-a60b-200ec00e903f", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-49d79f2b8dcf7315", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "def line(x: float) -> float:\n", + " '''\n", + " Evaluates the rounded line from the previous\n", + " evaluated linear regression model\n", + "\n", + " Note: Output rounded to 2 decimal places\n", + " '''\n", + " res: float = slope * x + intercept\n", + " rounded: np.float64 = np.round(res, decimals=2)\n", + " return float(rounded)" + ] + }, + { + "cell_type": "markdown", + "id": "8fdd9724-5c61-471d-a121-787f2d56f132", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-a63e440ba0b57186", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Diese kann über den gesatme bereich dargestellt werden. Dazu werden die bereits bekannten x-Werte verwendet:" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "0a59d146-4ae3-429a-a67e-7c158d5ebac7", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-5239bfcad5788ae3", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate the Line using vectorization\n", + "regline: np.array = np.vectorize(line)(x)\n", + "\n", + "# Plot tvalues\n", + "plt.title(\"Scattered Random Values\")\n", + "plt.grid()\n", + "\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "\n", + "plt.scatter(x,y, color='g', label=\"Original Data\")\n", + "plt.plot(x, regline, color='m', label=\"Fitted line\")\n", + "\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "802bf60a-e402-4912-96bf-baa6cd398c6e", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-e0da661ffad2086e", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Mit diesem Model lässt sich dementsprechend die \"Zukunft\" vorhersagen. Hierfür können wir im folgenden einfach die Werte für `-1` & `11` berechnen und diese dem Plot hinzufügen:" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "e62f6248-5813-4df0-9715-a72d3a5467f8", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-92a5bbb041e28a56", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Future Values\n", + "fut: np.array = np.array([line(-1), line(11)])\n", + "\n", + "# Calculate extended Line using vectorization\n", + "ext_range: np.array = np.arange(-1,12)\n", + "regline: np.array = np.vectorize(line)(ext_range)\n", + "\n", + "# Plot values\n", + "plt.title(\"Scattered Random Values\")\n", + "plt.grid()\n", + "\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "\n", + "plt.scatter(x,y, color='g', label=\"Original Data\")\n", + "plt.plot(ext_range, regline, color='m', label=\"Fitted Line\")\n", + "plt.scatter((-1, 11), fut, color='r', label=\"Predicted Data\")\n", + "\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "04f002a5-4339-4225-9515-848513347697", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-6c8576c776d11325", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Wie zu erwarten liegen beide Werte auf der Geraden.\n", + "\n", + "Um deren Werte zu ermitteln lassen sich diese mittels print einfach ausgeben, dies sollte immer mit Angabe des Standard Errors erfolgen. Sonst ist unklar wie genau die Daten sind:" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "563d452b-350c-4628-a97d-5d9ce268f4c4", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-7677ec5dda3e8e13", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prediction of f(11) = 10.16, with standard deviation 0.07\n" + ] + } + ], + "source": [ + "print(\"Prediction of f(11) = {}, with standard deviation {}\".format(line(11), np.round(stderr, decimals=2)))" + ] + }, + { + "cell_type": "markdown", + "id": "5e81b1a9-4155-4bfd-8613-2530dbe61f03", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-facd8e8ef9f4aed1", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Aufgabe\n", + "\n", + "*7 Punkte*\n", + "\n", + "Bestimme mittels Linearer Regression die *best fit* Funktion für die beiden gegebenen Datensets `x_data` & `y_data`, unter beachtung folgender Punkte:\n", + "\n", + "- Plotte das Ergebnis angemessen\n", + "- Nutze SciPys `linregress` Funktion, speichere den Output vor dem entpacken in der Variablen `l`\n", + "- Definiere die Funktion `reg_line` mit einem Eingabeparameter\n", + "- Bestimme die Werte für `-0.3` & `3.4` speichere diese als liste in variablen `future`\n" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "id": "f5b801bc-450e-417b-aeea-9b69d638fb64", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-cb5b277089c75c40", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "random = np.random.default_rng(420)\n", + "\n", + "# 2 scuffed up One-Liners :)\n", + "x_data: np.array = np.sort(np.round(random.random(40)*np.pi, decimals=2))\n", + "y_data: np.array = np.flip(np.sort(np.round(random.random(40)*np.sqrt(2), decimals=2)))" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "id": "2645541f-c30f-487e-be65-3ec5ac22d427", + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-12b5b631856ffe41", + "locked": false, + "points": 1, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# BEGIN SOLUTION\n", + "l = stats.linregress(x_data,y_data)\n", + "slope, intercept, _, _, stderr = l\n", + "\n", + "def reg_line(x: float) -> float:\n", + " return float(np.round(slope*x+intercept,decimals=2))\n", + "\n", + "ext: tuple = (-0.3, 3.4)\n", + "rl: np.array = np.vectorize(reg_line)(ext)\n", + "\n", + "future: list = [reg_line(ext[0]), reg_line(ext[1])]\n", + "# Plot values\n", + "plt.title(\"Scattered Random Values\")\n", + "plt.grid()\n", + "\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "\n", + "plt.scatter(x_data,y_data, color='g', label=\"Original Data\")\n", + "plt.plot(ext, rl, color='m', label=\"Fitted Line\")\n", + "plt.scatter(ext, future, color='r', label=\"Predicted Data\")\n", + "\n", + "plt.legend()\n", + "\n", + "plt.show()\n", + "# END SOLUTION" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "id": "aa34ed84-f200-4863-be0b-40ff5492c654", + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-8f20c3645d0a9b46", + "locked": true, + "points": 6, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# Hier werden ihre Lösungen getestet\n", + "\n", + "# Check if reg_line is defined\n", + "assert 'reg_line' in dir()\n", + "\n", + "# Check if reg_line gives right output\n", + "assert reg_line(10) == -3.04\n", + "\n", + "# Check if future values are calculated right\n", + "assert future == [1.51, -0.12]\n", + "\n", + "### BEGIN HIDDEN TESTS\n", + "sl, ip, _, _, se = stats.linregress(x_data,y_data)\n", + "slope, intercept, _, _, stderr = l\n", + "\n", + "assert slope == sl\n", + "assert intercept == ip\n", + "assert stderr == se\n", + "\n", + "### END HIDDEN TESTS" + ] + }, + { + "cell_type": "markdown", + "id": "8369e788-5862-488b-a003-d3cd31ebaa99", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-59872a1e95590378", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "02656b99-d250-4a21-bc2d-46007806d81d", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-455ed6a04d0d701f", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "# Verteilungen\n", + "\n", + "## Probability Density Function - Normal Verteilung\n", + "\n", + "### Motivation\n", + "\n", + "Es wurden Daten über die Körperlänge eines Bienenvolkes erhoben, dementsprechend liegen diskrete Werte über die deren Körperlängen vor. Logischerweise repräsentiert dies nur das erhobene Bienenvolk, dieses arbeitet aber kontinuierlich weiter und erzeugt nachkommen. Die Population verändert sich. \n", + "\n", + "Daher ist anzunehmen, dass auch Werte zwischen den bereits Erhobenen auftreten können. Um dies zu Modellieren wird eine Normalverteilung benötigt.\n", + "\n", + "Schauen wir uns dazu erst die Gaussche Normalverteilung an, diese hat ihren Mittelpunkt bei $x=0$, bezeichnet als Erwartungswert $\\mu$, und eine Standardabweichung $\\sigma = 1$. Mathematisch ist sie definiert als $$p(x|\\mu,\\sigma)=\\frac{1}{\\sqrt(2\\pi\\sigma^2)}e^{-\\frac{(x-\\mu)^2}{2\\sigma^2}}$$\n", + "\n", + "SciPy bietet hierfür das `norm` objekt aus dem `stats` Modul an, dieses verlangt die beiden Parameter $\\mu$ & $\\sigma$, das auf dem `norm` Objekt kann dann die Funktion `pdf` mit einem Paramter als Stepsize oder einem Array aufgerufen werden. Nach Plotten ergibt sich folglich die Normalverteilung (von -4 bis 4):" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "2803dcac-bb3b-4aff-a3c9-c0085148c376", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-54174b5f7d8309db", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.arange(-4, 4, 0.01) # Plot between -4 and 4 with stepsize 0.01\n", + "y = stats.norm(0,1).pdf(x) # Calculate pdf with mu=0, sigma=1\n", + "\n", + "# Plot\n", + "plt.title(\"Gaussche Normalverteilung\")\n", + "plt.plot(x, y)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ca2f768f-16ff-47ff-b898-fe0b8cf3511f", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-259b8d6cb9d76981", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Um herauszufinden wie viel Prozent einer Population innerhalb dieser Normalverteilung fallen wird die Funktion `ppf` (Percent Point Function) verwendet.\n", + "\n", + "Am Beispiel 90% der Population:" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "0e5e7709-90a2-4a30-b49f-cbb243aa4e4b", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-5a9ed9588ce2ea27", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "90% of the Population fall into the range 1.282.\n" + ] + } + ], + "source": [ + "percentile = stats.norm(0,1).ppf(0.9)\n", + "print(f\"90% of the Population fall into the range {percentile:0.3f}.\")" + ] + }, + { + "cell_type": "markdown", + "id": "96afa424-d697-4c60-aa9b-4655491f4f13", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-5102a53fda328278", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Um dies zu veranschaulichen:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4f5d7f54-856f-4e12-8251-d0cdc5c0f002", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-5d84b05b2808a672", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvUAAAIQCAYAAAABy5G8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABzoUlEQVR4nO3dd3gU5cLG4d8kIQktAQQSokiXokCOgIiCWKIB9SjHAlaKioqVLzbwKEU9UmwoIihKFaQ3EYIYARu9CNIEBKkJCZgKJJCd749NgoGA2ZDk3fLc1zXXTnZnN89u2pPZd96xbNu2ERERERERj+VnOoCIiIiIiFwYlXoREREREQ+nUi8iIiIi4uFU6kVEREREPJxKvYiIiIiIh1OpFxERERHxcCr1IiIiIiIeTqVeRERERMTDqdSLiIiIiHg4lXoRH7Znzx4sy2LcuHF51w0YMADLsvJtV7t2bbp3716in1fy6969O7Vr1853nWVZDBgwwFimC+HJ2d3JuHHjsCyLPXv2mI4iIm5GpV7Ei+UWgIKWPn36mI73j5YuXZovc5kyZahbty5du3bljz/+MB3vgh08eJABAwawYcMG01G8Su73y3vvvXfWbbk/E2vWrDGSrbRt2LCBhx56iJo1axIUFESVKlWIiopi7NixZGdnm44nIsUowHQAESl5b7zxBnXq1Ml33RVXXEGtWrU4fvw4ZcqUMZatMJ577jlatWrFyZMnWbduHZ999hnffPMNmzZtIiIiwnS8Ijt48CADBw6kdu3aREZG5rtt9OjROBwOY9m8wTvvvEOvXr0oV66c6ShGfP755zz55JOEhYXx8MMP06BBA9LS0oiLi+PRRx/l0KFDvPrqq6ZjikgxUakX8QEdO3akZcuWBd4WHBxc6nlc1a5dO+655x4AevTowWWXXcZzzz3H+PHj6du37wU9dkZGBuXLly+mpMXH3f/RMunEiRMEBgbi53fuN5sjIyPZsGEDo0aNIiYmpsSyuOv3z4oVK3jyySdp06YNCxYsoGLFinm39e7dmzVr1vDbb78Vy+dy19dAxNdo+I2ID7uQse3Jycn07t077239+vXrM2TIkLP2LicnJ9O9e3dCQ0OpVKkS3bp1Izk5+YJy33jjjQDs3r0777qFCxfSrl07ypcvT8WKFbntttvYvHlzvvt1796dChUqsGvXLm699VYqVqzIgw8+CIDD4eDDDz+kadOmBAcHU61aNTp06HDWMI0vv/ySFi1aULZsWapUqcJ9993Hvn378m1z/fXXc8UVV7BlyxZuuOEGypUrx8UXX8zQoUPztlm6dCmtWrWCnH9UcoeM5H4tChpTX5ADBw7wyCOPEBYWRlBQEJdffjljxoz5x/ud72t/5vj33OMsdu7cSffu3alUqRKhoaH06NGDY8eO5btvZmYm//d//0e1atWoWLEid9xxB/v37y9y9twhWFOmTOG1117j4osvply5cqSmpp73+V177bXceOONDB06lOPHj//j6/H999/nff9UqlSJO++8k61bt+bbJvd12LJlCw888ACVK1embdu2kHPcye23387SpUtp2bIlZcuWpWnTpixduhSAWbNm5X1vtWjRgvXr1+d77I0bN9K9e3fq1q1LcHAw4eHhPPLIIxw5cuQfsxdk4MCBWJbFpEmT8hX6XC1btsw7Tib3Nc7Nmqug75Fz/Qw988wzVKhQ4azvB4D777+f8PDwfMN9CvPzKiKu0Z56ER+QkpJCUlJSvuuqVq1a5Mc7duwY7du358CBAzzxxBNceuml/PLLL/Tt25dDhw4xbNgwAGzb5s477+Snn37iySefpHHjxsyePZtu3bpd0PPZtWsXABdddBEAEydOpFu3bkRHRzNkyBCOHTvGyJEjadu2LevXr89Xjk+dOkV0dDRt27bl3XffzRua8eijjzJu3Dg6duzIY489xqlTp/jxxx9ZsWJF3rsc//vf/3j99dfp3Lkzjz32GImJiQwfPpzrrruO9evXU6lSpbzP89dff9GhQwfuuusuOnfuzIwZM3jllVdo2rQpHTt2pHHjxrzxxhv069ePxx9/nHbt2gFwzTXXFPp1SEhI4Oqrr8ayLJ555hmqVavGwoULefTRR0lNTaV3794X9DqfqXPnztSpU4dBgwaxbt06Pv/8c6pXr86QIUPytnnsscf48ssveeCBB7jmmmv4/vvvue222y44+5tvvklgYCAvvvgimZmZBAYG/mPeAQMGcN111zFy5Mjz7q3/7rvv6NixI3Xr1mXAgAEcP36c4cOHc+2117Ju3bqz/rm69957adCgAW+//Ta2beddv3PnTh544AGeeOIJHnroId59913+/e9/M2rUKF599VWeeuopAAYNGkTnzp3Zvn173rsNixcv5o8//qBHjx6Eh4ezefNmPvvsMzZv3syKFSvOOnj9fI4dO0ZcXBzXXXcdl156aaHvV1gF/QzVrl2bESNG8M0333Dvvffmy/L111/TvXt3/P39wcWfVxFxgS0iXmvs2LE2UOBi27a9e/duG7DHjh2bd5/+/fvbZ/5qqFWrlt2tW7e8j9988027fPny9u+//55vuz59+tj+/v723r17bdu27Tlz5tiAPXTo0LxtTp06Zbdr1+6sz1uQJUuW2IA9ZswYOzEx0T548KD9zTff2LVr17Yty7JXr15tp6Wl2ZUqVbJ79uyZ777x8fF2aGhovuu7detmA3afPn3ybfv999/bgP3cc8+dlcHhcNi2bdt79uyx/f397f/973/5bt+0aZMdEBCQ7/r27dvbgD1hwoS86zIzM+3w8HD77rvvzrtu9erV53wdunXrZteqVSvfdYDdv3//vI8fffRRu0aNGnZSUlK+7e677z47NDTUPnbsWIGvq32Or/25Pk/u98QjjzySb7v//Oc/9kUXXZT38YYNG2zAfuqpp/Jt98ADDxQ5e+73QN26dc/7fM7M//TTT9u2bds33HCDHR4ennff3J+J1atX520fGRlpV69e3T5y5Ejedb/++qvt5+dnd+3a9azX4f777z/rc9aqVcsG7F9++SXvukWLFtmAXbZsWfvPP//Mu/7TTz+1AXvJkiV51xX03L766isbsH/44Ye863Lz7969+5zP/9dff7UB+/nnny/Eq3X6Nf57Hvsc3yPn+hlyOBz2xRdfnO/727Zte9q0afmegys/ryLiGg2/EfEBI0aMYPHixfmWCzF9+nTatWtH5cqVSUpKyluioqLIzs7mhx9+AGDBggUEBATQq1evvPv6+/vz7LPPuvT5HnnkEapVq0ZERAS33XYbGRkZjB8/npYtW7J48WKSk5O5//7782Xx9/endevWLFmy5KzH+3segJkzZ2JZFv379z9r29w9pLNmzcLhcNC5c+d8nyc8PJwGDRqc9XkqVKjAQw89lPdxYGAgV111VbHN2mPbNjNnzuTf//43tm3nyxQdHU1KSgrr1q0rls+V68knn8z3cbt27Thy5EjeUJgFCxZAzoHNf3fmXveiZO/WrRtly5Z1OfOAAQOIj49n1KhRBd5+6NAhNmzYQPfu3alSpUre9c2aNePmm2/Oe07nex1yNWnShDZt2uR93Lp1a8gZLvb3Pea51//9e+Hvz+3EiRMkJSVx9dVXA7j8dcz9ehQ07Ka4nPkzZFkW9957LwsWLCA9PT3v+qlTp3LxxRfnDVMqys+riBSOht+I+ICrrrrqnAfKFsWOHTvYuHEj1apVK/D2w4cPA/Dnn39So0YNKlSokO/2hg0buvT5+vXrR7t27fD396dq1ao0btyYgICAvCz8bZz9mUJCQvJ9HBAQwCWXXJLvul27dhEREZGv1J1px44d2LZNgwYNCrz9zANbL7nkkrOGTFSuXJmNGzee97kWVmJiIsnJyXz22Wd89tlnBW6T+3UoLmcO5ahcuTLkDDUKCQnhzz//xM/Pj3r16uXb7syvd1Gynzl7U2Fdd9113HDDDQwdOrTAMv7nn38WmBGgcePGLFq06KwDQc+V5czXJzQ0FICaNWsWeP1ff/2Vd93Ro0cZOHAgU6ZMOeu5p6SkFOq55sr9nk9LS3PpfoVV0M8QQJcuXRg2bBjz5s3jgQceID09nQULFvDEE0/k/Sy4+vMqIoWnUi8iLnM4HNx88828/PLLBd5+2WWXFevna9q0KVFRUefMQs443fDw8LNuzy3/uYKCgs47a8q5OBwOLMti4cKFeWOD/+7Mf1wK2oacvdTFIfd5P/TQQ+c8RqFZs2bnvP+5xmifb+7y4npORclelL30ufr378/111/Pp59+mu+4h6I6V5ZzvT6Fed06d+7ML7/8wksvvURkZCQVKlTA4XDQoUMHl6c2rV+/PgEBAWzatKlQ27v6vXCun6Grr76a2rVrM23aNB544AG+/vprjh8/TpcuXfK2cfXnVUQKTz89IuKyevXqkZ6efs6inatWrVrExcWRnp6er/Ru3769WLMAVK9e/R/znO8xFi1axNGjR8+5t75evXrYtk2dOnWK7Z8WVw5+PFPu7DLZ2dlFet65e9nPnIkod891UdSqVQuHw8GuXbvy7fk+8+t9odld1b59e66//nqGDBlCv379zspcUEaAbdu2UbVq1RKfrvGvv/4iLi6OgQMH5suXu1fbVeXKlePGG2/k+++/Z9++fWe9U3Cm4vxe6Ny5Mx9++CGpqalMnTqV2rVr5w0joph+XkWkYBpTLyIu69y5M8uXL2fRokVn3ZacnMypU6cAuPXWWzl16hQjR47Muz07O5vhw4cXW5bo6GhCQkJ4++23OXny5Fm3JyYm/uNj3H333di2zcCBA8+6LXdv6l133YW/vz8DBw48a8+0bdtFmnowtywWZYpPf39/7r77bmbOnFngfOP/9LxDQkKoWrVq3vEPuT755BOXs+Tq2LEjAB999FG+63NnQyqu7EWRO7b+zOE+NWrUIDIykvHjx+f7Ovz22298++233HrrrcWe5Uy5e/LP/L4683VzRf/+/bFtm4cffjjfGPdca9euZfz48ZDzj42/v3+xfC906dKFzMxMxo8fT2xsLJ07d853e3H8vIpIwbSnXkRc9tJLLzFv3jxuv/12unfvTosWLcjIyGDTpk3MmDGDPXv2ULVqVf79739z7bXX0qdPH/bs2UOTJk2YNWuWy2OEzyckJISRI0fy8MMPc+WVV3LfffdRrVo19u7dyzfffMO1117Lxx9/fN7HuOGGG3j44Yf56KOP2LFjR96Qhx9//JEbbriBZ555hnr16vHWW2/Rt29f9uzZQ6dOnahYsSK7d+9m9uzZPP7447z44osuZa9Xrx6VKlVi1KhRVKxYkfLly9O6detCjx8fPHgwS5YsoXXr1vTs2ZMmTZpw9OhR1q1bx3fffcfRo0fPe//HHnuMwYMH89hjj9GyZUt++OEHfv/9d5eew99FRkZy//3388knn5CSksI111xDXFwcO3fuLPbsrmrfvj3t27dn2bJlZ932zjvv0LFjR9q0acOjjz6aN6VlaGhovvn6S0pISAjXXXcdQ4cO5eTJk1x88cV8++23+c7D4KprrrmGESNG8NRTT9GoUaN8Z5RdunQp8+bN46233oKcMf733nsvw4cPx7Is6tWrx/z584t0TMaVV15J/fr1+e9//0tmZma+oTcU08+riBRMpV5EXFauXDmWLVvG22+/zfTp05kwYQIhISFcdtllDBw4MO9AQD8/P+bNm0fv3r358ssvsSyLO+64g/fee49//etfxZbngQceICIigsGDB/POO++QmZnJxRdfTLt27ejRo0ehHmPs2LE0a9aML774gpdeeonQ0FBatmyZb974Pn36cNlll/HBBx/k7dWvWbMmt9xyC3fccYfLucuUKZN3Vtwnn3ySU6dOMXbs2EKX+rCwMFatWsUbb7zBrFmz+OSTT7jooou4/PLL880dfy79+vUjMTGRGTNmMG3aNDp27MjChQupXr26y88l15gxY6hWrRqTJk1izpw53HjjjXzzzTdnDQG50OxFMWDAAG644Yazro+KiiI2Npb+/fvTr18/ypQpQ/v27RkyZEiRD9B11eTJk3n22WcZMWIEtm1zyy23sHDhQiIiIor8mE888QStWrXivffeY8KECSQmJlKhQgWuvPJKxo4dm292puHDh3Py5ElGjRpFUFAQnTt35p133uGKK65w+fN26dKF//3vf9SvX58rr7zyrNuL4+dVRM5m2cV11JaIiIiIiBihMfUiIiIiIh5OpV5ERERExMOp1IuIiIiIeDiVehERERERD6dSLyIiIiLi4VTqRUREREQ8nFfMU+9wODh48CAVK1a8oNOui4iIiIi4E9u2SUtLIyIiAj+/c++P94pSf/DgwbNObCIiIiIi4i327dvHJZdccs7bvaLUV6xYEXKebEhIiOk4IiIiIiLFIjU1lZo1a+b13XPxilKfO+QmJCREpV5EREREvM4/DTHXgbIiIiIiIh5OpV5ERERExMOp1IuIiIiIeDiVehERERERD6dSLyIiIiLi4VTqRUREREQ8nEq9iIiIiIiHU6kXEREREfFwKvUiIiIiIh5OpV5ERERExMOp1IuIiIiIeDiVehERERERD6dSLyIiIiLi4YpU6keMGEHt2rUJDg6mdevWrFq1qlD3mzJlCpZl0alTp3zX27ZNv379qFGjBmXLliUqKoodO3YUJZqIiIiIiM9xudRPnTqVmJgY+vfvz7p162jevDnR0dEcPnz4vPfbs2cPL774Iu3atTvrtqFDh/LRRx8xatQoVq5cSfny5YmOjubEiROuxhMRERER8Tkul/r333+fnj170qNHD5o0acKoUaMoV64cY8aMOed9srOzefDBBxk4cCB169bNd5tt2wwbNozXXnuNO++8k2bNmjFhwgQOHjzInDlzivasRERERER8iEulPisri7Vr1xIVFXX6Afz8iIqKYvny5ee83xtvvEH16tV59NFHz7pt9+7dxMfH53vM0NBQWrdufc7HzMzMJDU1Nd8iIiIiIuKrAlzZOCkpiezsbMLCwvJdHxYWxrZt2wq8z08//cQXX3zBhg0bCrw9Pj4+7zHOfMzc2840aNAgBg4c6Ep0EREpquxsWLUKVqyA336DgwchMxP8/SE8HBo0gKuugnbtoHx502lFRHySS6XeVWlpaTz88MOMHj2aqlWrFtvj9u3bl5iYmLyPU1NTqVmzZrE9voiI4Czwn3yCPX06VlLSP26eHRSI3bEjAU8/AzfdBJZVKjFFRMTFUl+1alX8/f1JSEjId31CQgLh4eFnbb9r1y727NnDv//977zrHA6H8xMHBLB9+/a8+yUkJFCjRo18jxkZGVlgjqCgIIKCglyJLiIihfX779CnD8yeDYAFHA2GH2vD+nDYGwIZgRCYDRFpcMVhaLcXaidnwZy5MGcux5s2ouywEXDjjaafjYiIT3Cp1AcGBtKiRQvi4uLypqV0OBzExcXxzDPPnLV9o0aN2LRpU77rXnvtNdLS0vjwww+pWbMmZcqUITw8nLi4uLwSn5qaysqVK+nVq9eFPTsRESm848fhtdewP/oI69Qpsi2Y0xg+vRKW1IFT/ue5rw2R8fDIeui+ASpu2gY33URGhxsp/8VEiIgoxSciIuJ7XB5+ExMTQ7du3WjZsiVXXXUVw4YNIyMjgx49egDQtWtXLr74YgYNGkRwcDBXXHFFvvtXqlQJIN/1vXv35q233qJBgwbUqVOH119/nYiIiLPmsxcRkRLy66/w4IOweTMW8M1l8HIUbKleyPtbsKEGPFcD3mgP/ZbBk2ugfOz3HGtcn6AvxuN/z70l/CRERHyXy6W+S5cuJCYm0q9fP+Lj44mMjCQ2NjbvQNe9e/fi5+faTJkvv/wyGRkZPP744yQnJ9O2bVtiY2MJDg52NZ6IiLjqyy+xH30UKyuL+PLw2J3OUl9USeXhuVthZEuYOBtaHDoO93Ym9alHCfnoU+cBtiIiUqws27Zt0yEuVGpqKqGhoaSkpBASEmI6joiIZ7BteOMNGDAAgPmXQY87naW8uJQ5BW8sgT4/Oz9OurktVWfHapYcEZFCKmzPdfnkUyIi4gUcDnjiibxCP7StxR33FW+hBzgZAH1vhi73wIkAqLr4J460iYTk5OL9RCIiPk6lXkTE1zgc0KsXjB5NtgW9brd4JcrGLsG/CNOugBu7QlJZuGjTTg63awE6caCISLFRqRcR8SW2Dc8+C599RrYF3e+yGNWydEZhLr8UbuoGR8pC9d/+IKHdlZCeXiqfW0TE26nUi4j4krffhk8+wWHBI/+x+LJp6R5WtTEcoro6570P27iLg7e1d56xVkRELohKvYiIr/jqK3jtNQCeu9ViQjMz8yRsqAEdH4LjARDxwzoOPHKv8x0EEREpMpV6ERFf8Msv2N27A/DBNRYjWpkt0asugYfucq5fPGE2h4f0M5pHRMTTqdSLiHi7w4exO3fGyspibiN4Mco99orPagIv3excr/zft8hYuth0JBERj6VSLyLizbKz4cEHsQ4cYNtF8NB/wOFGv/nfvQamXA5lHHD87juwDx82HUlExCO50a92EREpdm++Cd99R0YZuLsLpAeZDnQGC3reAdsugqpHT7D39nbOKTdFRMQlKvUiIt7ql1+w33wTgKf+bbGluulABUsPcv7DkVEGaq3+nX1vvGg6koiIx1GpFxHxRunp0LUrlsPBl83MzXRTWFuqQ0y0c736/4ZxbMNq05FERDyKSr2IiDd66SXYtYt9IfBMR/cu9Lk+awHfNICgUzZJ99wKWVmmI4mIeAyVehERbxMXB6NGAdCjE6SUNR2okCx47A5IKguX7krij5d7mk4kIuIxVOpFRLzJiRPQqxcAn7SyiKtrOpBr4ivCM7c61y/+eALHNq4zHUlExCOo1IuIeJNBg2DHDg5WgL43ecawmzNNvQIW1IegbDj44B2aDUdEpBBU6kVEvMX27diDBwPwfx0gNdh0oCKy4KnbnLPh1P/tAH9+MMB0IhERt6dSLyLiDWwbnnwSKyuL2Pow7XLTgS7Mn5Wh3w3O9ZD+b+M4esR0JBERt6ZSLyLiDb76CpYu5VgZ6HWbc2+3p/uwNfxWDSpnZLP5mS6m44iIuDWVehERT3f8OHafPgAMamexp7LpQMUj2985jAig0dQ4UjasNB1JRMRtqdSLiHi6Dz7A2rePvSHwbhvPPDj2XL6rB/MugzIOONBTe+tFRM5FpV5ExJPFx2MPGgRA3yg4UcZ0oOL3QjRk+UGTNX+yf+po03FERNySSr2IiCfr3x8rPZ1VEfDVFabDlIydF8FHrZ3rdkwMnDplOpKIiNtRqRcR8VS//Yb9+ecAxESD7cW/0d9sD4nloObBdH7/4DXTcURE3I4X/wkQEfFyr76K5XAwswn8XMt0mJKVGgyD2jrXQwZ9gH3ihOlIIiJuRaVeRMQTrVoFX39NtgWv3mg6TOkY2Qr2V4Twv7L47c1nTccREXErKvUiIp6oXz8Avmxu8XtV02FKx4ky8EZ753qN4WPJTks1HUlExG2o1IuIeJqffoJFizjpBwOv864pLP/J2H/BzspQNS2bTa/1NB1HRMRtqNSLiHia118HYNy/LHZXMR2mdJ3yh/43ONfrjJ7BqaNJpiOJiLgFlXoREU/y/fewdCmZ/vBmO9/aS59ryhXwWzUIPe7gt9efMB1HRMQtqNSLiHiSAQMA+LyFxb5KpsOY4fCDt65zrtcaN4dTqcmmI4mIGKdSLyLiKX76CX78kSx/eLutb+6lzzX9cvi9ClQ+5mDjwKdNxxERMU6lXkTEUwwaBMCE5hYHQ0yHMcvhB4Nz5q2/5POpOI5lmI4kImKUSr2IiCf49VdYsIBsC4Zc69t76XN92Qz+DIXqqdlsHPR/puOIiBilUi8i4gkGDwZgZhOLnReZDuMeTgbA0Gud62GfjMPOzDQdSUTEGJV6ERF3t3Mn9rRpAAzy8bH0ZxrzLzhUAWocPcnWD183HUdExBiVehERd/fOO1gOBwsbwIYapsO4lxNlYNjVzvXg4SPB1j89IuKbVOpFRNzZ4cPY48cD8HZb02Hc02ctIL0M1N2fzq6po0zHERExQqVeRMSdffopVmYmKy+Gny41HcY9JZeFL650rmcMftN0HBERI1TqRUTcVWYm9ogRQM4QE8t0IPc17GrItqDZr4eIX77YdBwRkVKnUi8i4q6mTsVKSOBARZjRxHQY97anMsxq7FzfPyDGdBwRkVKnUi8i4o5sG4YNA+CTqyxO+ZsO5P7ea+O8bBb3Gxl/7jQdR0SkVBWp1I8YMYLatWsTHBxM69atWbVq1Tm3nTVrFi1btqRSpUqUL1+eyMhIJk6cmG+b7t27Y1lWvqVDhw5FiSYi4h1+/BHWr+dYAIxqoRldCmNlTfi5JgRmw9Y3njUdR0SkVLlc6qdOnUpMTAz9+/dn3bp1NG/enOjoaA4fPlzg9lWqVOG///0vy5cvZ+PGjfTo0YMePXqwaNGifNt16NCBQ4cO5S1fffVV0Z+ViIiny9lL/2WkxdFypsN4jg9ypresPW0xjhPHTccRESk1Lpf6999/n549e9KjRw+aNGnCqFGjKFeuHGPGjClw++uvv57//Oc/NG7cmHr16vH888/TrFkzfvrpp3zbBQUFER4enrdUrly56M9KRMST/fEH9pw5AAy7SnvpXTG3ERyoCFXTs9n4SX/TcURESo1LpT4rK4u1a9cSFRV1+gH8/IiKimL58uX/eH/btomLi2P79u1cd911+W5bunQp1atXp2HDhvTq1YsjR464Ek1ExHt8/DGWbbOoPmytbjqMZznlD5+2cK6XGTXadBwRkVLjUqlPSkoiOzubsLCwfNeHhYURHx9/zvulpKRQoUIFAgMDue222xg+fDg333xz3u0dOnRgwoQJxMXFMWTIEJYtW0bHjh3Jzs4u8PEyMzNJTU3Nt4iIeIWMDOwvvgBgWGvTYTzTZy0gyw8u35HM3iVzTccRESkVAaXxSSpWrMiGDRtIT08nLi6OmJgY6taty/XXXw/Afffdl7dt06ZNadasGfXq1WPp0qXcdNNNZz3eoEGDGDhwYGlEFxEpXV99hZWayo4qsKie6TCeKaEizGwC9/8GB4b8l0tvuNN0JBGREufSnvqqVavi7+9PQkJCvusTEhIIDw8/9yfx86N+/fpERkbywgsvcM899zBo0KBzbl+3bl2qVq3Kzp0FT0nWt29fUlJS8pZ9+/a58jRERNzXqFEAjG5pYWvS4SIb0cp52fz7zWQk7DcdR0SkxLn0JyMwMJAWLVoQFxeXd53D4SAuLo42bdoU+nEcDgeZmZnnvH3//v0cOXKEGjVqFHh7UFAQISEh+RYREY+3ejWsXcsJfxjTXAfIXoifL4Vfw6DcSfhtyAum44iIlDiX9wPFxMQwevRoxo8fz9atW+nVqxcZGRn06NEDgK5du9K3b9+87QcNGsTixYv5448/2Lp1K++99x4TJ07koYceAiA9PZ2XXnqJFStWsGfPHuLi4rjzzjupX78+0dHRxflcRUTcW85e+plXWBwpbzqMh7NO762v8eUc7HMcoyUi4i1cHlPfpUsXEhMT6devH/Hx8URGRhIbG5t38OzevXvx8zv9v0JGRgZPPfUU+/fvp2zZsjRq1Igvv/ySLl26AODv78/GjRsZP348ycnJREREcMstt/Dmm28SFBRUnM9VRMR9/fUX9ldfYQGf6GRTxWJSMxi6GC5NzGL75OE0fLi36UgiIiXGsm3b4/96pKamEhoaSkpKiobiiIhn+ugjeP55NlaH5r2ce5rlwr0fC/+3Ata2vpQWK/40HUdExGWF7bk6DEtExDTbzht682lLFfriNPpK52Xz1XtJ2b3NdBwRkRKjUi8iYtoPP8DWraSXgYnNTIfxLlurw881IcABm9992XQcEZESo1IvImJazl76r5pbpAWbDuN9Ps/ZW3/JtFgdMCsiXkulXkTEpCNHsGfNAmDklR5/iJNbmnY5pAbCpUkn2TbzU9NxRERKhEq9iIhJkyZhZWWxLhzWR5gO452OBcLkps711BHvmY4jIlIiVOpFREyxbfjiCwDGXKmjY0vS6BbOy8if/yDt4B7TcUREip1KvYiIKevXw8aNnPCHyVdo6E1JWlcD1odDUDZsfr9vIe4hIuJZVOpFREwZMwaAOY0t/ipnOoyXs05Pb1n1q7nOd0lERLyISr2IiAknTmBPmgTAF/9SwSwNk5vCsQCof/A4u2Onmo4jIlKsVOpFREyYMwcrOZk/Q+H7OqbD+IaUsjD9cud6wvBBpuOIiBQrlXoRERNyht5MiLRw6DdxqRkX6bxs8v0mTqanmo4jIlJs9KdERKS0/fkn9nffATAmUkNvStOyWrAnFEIybX797A3TcUREio1KvYhIaRs/Hsu2+a4u7KlsOoxvsf1gYnPnut+EiabjiIgUG5V6EZHSZNvY48YBMDbSdBjfNCGn1DffeJiju34zHUdEpFio1IuIlKaff8bavZvUQJjdyHQY37TzIvi5JvjbsGXYa6bjiIgUC5V6EZHSNNE55GP25RbHA02H8V3jc/bWh89cpDnrRcQrqNSLiJSWEyewp00DYHxTFUmTpl0OJ/yh/qET7Ppuuuk4IiIXTKVeRKS0fPMNVnIy+0JgaW3TYXxbSlmYkzP8Kf6ToabjiIhcMJV6EZHSkjP05qtmFrZ++xo3PudA5UbfriP7xHHTcURELoj+rIiIlIYjR7AXLABggobeuIXFdeFQBbjomM1vY4eYjiMickFU6kVESsO0aVgnT7I+HDaHmQ4jANn+MKmpcz1zwljTcURELohKvYhIacgZevNlc8t0EvmbSc2cl83W7OVY0iHTcUREikylXkSkpO3cCcuXk23B5Cs09MadbAiHLVUh+BRsHDXQdBwRkSJTqRcRKWlffgnAd/UgvqLpMJKPBZNzhuAETZ1hOo2ISJGp1IuIlCTbxs4p9RObmg4jBckt9c02HyFp1ybTcUREikSlXkSkJK1YgbVrF+llYHZj02GkILurwPJLwN+GrR9rCI6IeCaVehGRkpSzl35OE4tjgabDyLnkzoJTZU6s6SgiIkWiUi8iUlJOncKePh2AL3WArFubdjmcsuDyPRnsXRNnOo6IiMtU6kVESsr332MlJpJYDuLqmg4j55NYARbXc67v+eRt03FERFymUi8iUlKmTAFg5uUWp/xNh5F/knvAbM1vfgRb76yIiGdRqRcRKQmZmdizZgEw+XIVRE8wpxEcC4A6h0+yY/E003FERFyiUi8iUhJiY7FSUthfEX661HQYKYz0IJjX0Lme8Nl7puOIiLhEpV5EpCTkDL2Z3tTC1m9aj5E7BKfB4rXYp06ZjiMiUmj6UyMiUtwyMrDnzQMNvfE4sfXhaDCEpTrYOnOU6TgiIoWmUi8iUty+/hrr2DF2VoY1EabDiCtOBsDMJs71vyZ8ajqOiEihqdSLiBS3nKE305paYJkOI66adrnzsuGyzWRnZZqOIyJSKCr1IiLFKTkZe+FC0NAbj7WkNiSVhaoZNr9N+9h0HBGRQlGpFxEpTrNnY2Vl8Vs12BxmOowURbb/6SE4qV9+bjqOiEihqNSLiBSnnKE3U5tq3I0nm5ozBOfyH7dzKvO46TgiIv9IpV5EpLgcPowdFwfAVxp649F+qAUJ5aHKMZuNk4eZjiMi8o9U6kVEisvMmVjZ2ayOgF0XmQ4jFyLbH2Y2dq5nTB5rOo6IyD9SqRcRKS4zZjgvLtfQG2+QOwvOFT/v4OTxDNNxRETOq0ilfsSIEdSuXZvg4GBat27NqlWrzrntrFmzaNmyJZUqVaJ8+fJERkYyceLEfNvYtk2/fv2oUaMGZcuWJSoqih07dhQlmoiIGYcPYy9dCsC0Jhp64w1+rAWHKkDl4/DrpPdMxxEROS+XS/3UqVOJiYmhf//+rFu3jubNmxMdHc3hw4cL3L5KlSr897//Zfny5WzcuJEePXrQo0cPFi1alLfN0KFD+eijjxg1ahQrV66kfPnyREdHc+LEiQt7diIipWXOHCyHgzU1YE9l02GkODj8YEbOLDgnJk8wHUdE5Lws27Zd2qXUunVrWrVqxccfO+fudTgc1KxZk2effZY+ffoU6jGuvPJKbrvtNt58801s2yYiIoIXXniBF198EYCUlBTCwsIYN24c99133z8+XmpqKqGhoaSkpBASEuLK0xERKR433wzffUefKIshbbWn3lu0/RN+HAvJwVDuSCqB5SqajiQiPqawPdelPfVZWVmsXbuWqKio0w/g50dUVBTLly//x/vbtk1cXBzbt2/nuuuuA2D37t3Ex8fne8zQ0FBat259zsfMzMwkNTU13yIiYkxSEvaSJQBM19Abr/JzTThQESqdgI1fagiOiLgvl0p9UlIS2dnZhIXlP6NKWFgY8fHx57xfSkoKFSpUIDAwkNtuu43hw4dz8803A+Tdz5XHHDRoEKGhoXlLzZo1XXkaIiLFa84crOxs1oXDH1VMh5HiZPvB9JwhOFmTJ/7T5iIixpTK7DcVK1Zkw4YNrF69mv/973/ExMSwNOeAsqLo27cvKSkpecu+ffuKNa+IiEtyZr2ZqVlvvFLeLDgr/iArQ+8Mi4h7cqnUV61aFX9/fxISEvJdn5CQQHh4+Lk/iZ8f9evXJzIykhdeeIF77rmHQYMGAeTdz5XHDAoKIiQkJN8iImLE0aN5J5ya3lhDb7zRiktgXwiEZMLGCe+YjiMiUiCXSn1gYCAtWrQgLucPGDkHysbFxdGmTZtCP47D4SAzMxOAOnXqEB4enu8xU1NTWblypUuPKSJixNy5WKdO8WsY7KhqOoyUBNvv9N76U19NMh1HRKRAAa7eISYmhm7dutGyZUuuuuoqhg0bRkZGBj169ACga9euXHzxxXl74gcNGkTLli2pV68emZmZLFiwgIkTJzJy5EgALMuid+/evPXWWzRo0IA6derw+uuvExERQadOnYr7+YqIFK/p0yHvhFPaU++tpjeBF5ZDk1W7yTqWpllwRMTtuFzqu3TpQmJiIv369SM+Pp7IyEhiY2PzDnTdu3cvfn6n3wDIyMjgqaeeYv/+/ZQtW5ZGjRrx5Zdf0qVLl7xtXn75ZTIyMnj88cdJTk6mbdu2xMbGEhwcXFzPU0Sk+P31F/Z332Fp6I3XW3Ux7K8Il6TBui8/4MrH+5mOJCKSj8vz1LsjzVMvIkaMHw/du7OpOjR7ynQYKWkfLoDnVsFPNzagbdzvpuOIiI8okXnqRUTkb3JnvWmiWW98wcycqS0vX76TU5nHTccREclHpV5EpChSUrC//RaAaTrhlE/46VJIKA+Vj9tsmjrcdBwRkXxU6kVEimLePKysLDZXg63VTYeR0uDwgzmNnOtpX40zHUdEJB+VehGRosgZejNLQ298yszGzstGP20j+2SW6TgiInlU6kVEXJWair1oEQBTNfTGpyypA38FQ/V0m99mf2o6johIHpV6ERFXzZ+PlZnJtotgs4be+JRT/jCvoXM9edIXpuOIiORRqRcRcVXurDeXW6DRNz4ndwhO/WWbcGSfMh1HRARU6kVEXHTsGHZsLAAzdMIpn/RtPUgLhItTHGxZMN50HBERUKkXEXHRokVYx4+zuxJsCDcdRkzILAPfNHCuJ038zHQcERFQqRcRcdGsWQDMaaKhN74s90RUdb5fh+1wmI4jIqJSLyJSaFlZ2PPnAzCzoYbe+LKF9eF4ANQ6coodS2aYjiMiolIvIlJoS5diJScTXx6W1zQdRkzKCILY+s71g+M/Nh1HRESlXkSk0GbPBuDrxhYO/fb0ebmz4Fy8eKXpKCIiKvUiIoWSnY2dU+pnNNLQG4H5l0GWHzSIz2L3ioWm44iIj1OpFxEpjBUrsBISSA6CJbVNhxF3kFIWvqvrXN87ZpjpOCLi41TqRUQKI2cv/YKGFicDTIcRd5E7C05Y7I+mo4iIj1OpFxH5J7aNnTOV5UwNvZG/mdsQTlnQaN9xDv76s+k4IuLDVOpFRP7Jxo1Yu3dzPOD0jCciAEfKww+1nOu7xr5nOo6I+DCVehGRf5Kzl/7b+nAs0HQYcTdzGjkvQxbGmY4iIj5MpV5E5J/kjKef2ch0EHFHuaX+ih2pHNmz1XQcEfFRKvUiIuezcyds2sQpyzmFociZ9lWCtTXA34atY4eajiMiPkqlXkTkfHL20i+tA3+VMx1G3NXsnL31gfMWmI4iIj5KpV5E5HxyxtPP0tAbOY/ZOWeXbfbbYdKPHDIdR0R8kEq9iMi5HDwIK1bA38ZNixRkSzXYUQWCT8GmCe+ajiMiPkilXkTkXObMAWD5JXAoxHQYcWvW6SE4jpkzTKcRER+kUi8ici454+lnN7ZMJxEPkDcLzpq9ZB1PNx1HRHyMSr2ISEGOHsVesgSAWTqLrBTCikvgUAUIzYSNUz40HUdEfIxKvYhIQebPx8rOZmN12HWR6TDiCWw/mNvQuZ4+bZLpOCLiY1TqRUQKkjPrzVwNvREX5A7BafTzNhzZp0zHEREfolIvInKmjAzsRYsAmNFYQ2+k8L6vAylBEJ5m89vXY0zHEREfolIvInKm2FisEyf4oxJsDDMdRjzJyQBY0MC5fuSrL0zHEREfolIvInKmnFlv5jaxQKNvxEW5U1vWWrIO2+EwHUdEfIRKvYjI3508iT1/PgAzNOuNFMHCBpDpD3UTT7Hrp69NxxERH6FSLyLyd8uWYaWkkFDeOUWhiKvSg+C7us71/RM/Nh1HRHyESr2IyN/lnEV2fiMLh35DShHlDsGp9u3PpqOIiI/QnywRkVy2jZ1T6mc11NAbKbqvG4IDuHzvcQ5uXmk6joj4AJV6EZFca9diHThAehmIq2M6jHiywxXg50ud6zvHvms6joj4AJV6EZFcOXvpYxtAZhnTYcTT5Q7BqfDNd6ajiIgPUKkXEcmVU+pzy5jIhcg9u2yz35NJ3r/LdBwR8XIq9SIiADt2wObNnPQ7ffIgkQuxuwr8GgYBDtgybqjpOCLi5VTqRUQA5s4FYGltSC5rOox4i9x3ffznab56ESlZKvUiIpweejNXQ2+kGOUOwWm64RDHU46YjiMiXqxIpX7EiBHUrl2b4OBgWrduzapVq8657ejRo2nXrh2VK1emcuXKREVFnbV99+7dsSwr39KhQ4eiRBMRcV1CAvYvvwAwt6HpMOJNfg2H3ZWg3En4beJ7puOIiBdzudRPnTqVmJgY+vfvz7p162jevDnR0dEcPny4wO2XLl3K/fffz5IlS1i+fDk1a9bklltu4cCBA/m269ChA4cOHcpbvvrqq6I/KxERV3z9NZZtszoC9oeaDiNexTq9tz5r1nTTaUTEi7lc6t9//3169uxJjx49aNKkCaNGjaJcuXKMGTOmwO0nTZrEU089RWRkJI0aNeLzzz/H4XAQFxeXb7ugoCDCw8PzlsqVKxf9WYmIuCJn6M28RpbpJOKFcsfVN1mxi+zME6bjiIiXcqnUZ2VlsXbtWqKiok4/gJ8fUVFRLF++vFCPcezYMU6ePEmVKlXyXb906VKqV69Ow4YN6dWrF0eOnHvsYWZmJqmpqfkWEZEiSUvD/s45j/isRjqLrBS/ny+FxHJQ+bjNllmfmo4jIl7KpVKflJREdnY2YWFh+a4PCwsjPj6+UI/xyiuvEBERke8fgw4dOjBhwgTi4uIYMmQIy5Yto2PHjmRnZxf4GIMGDSI0NDRvqVmzpitPQ0TktEWLsDIz2VEFtlQzHUa8kcMP5uUcq5E8dbzpOCLipQJK85MNHjyYKVOmsHTpUoKDg/Ouv++++/LWmzZtSrNmzahXrx5Lly7lpptuOutx+vbtS0xMTN7HqampKvYiUjS5Q28aW2BpT72UjDmN4NH1UHfZRmyHA8tPk8+JSPFy6bdK1apV8ff3JyEhId/1CQkJhIeHn/e+7777LoMHD+bbb7+lWbNm5922bt26VK1alZ07dxZ4e1BQECEhIfkWERGXnTyJPX8+ALMaqtBLyfmuLqSXgYuTs/kjbobpOCLihVwq9YGBgbRo0SLfQa65B722adPmnPcbOnQob775JrGxsbRs2fIfP8/+/fs5cuQINWrUcCWeiIhrli3DSkkhoTysuMR0GPFmJ8pAbH3n+qGJn5iOIyJeyOX3/2JiYhg9ejTjx49n69at9OrVi4yMDHr06AFA165d6du3b972Q4YM4fXXX2fMmDHUrl2b+Ph44uPjSU9PByA9PZ2XXnqJFStWsGfPHuLi4rjzzjupX78+0dHRxflcRUTyyxl6M7+RhUOjIaSE5U5tGR630nQUEfFCLo+p79KlC4mJifTr14/4+HgiIyOJjY3NO3h27969+P1trODIkSPJysrinnvuyfc4/fv3Z8CAAfj7+7Nx40bGjx9PcnIyERER3HLLLbz55psEBQUVx3MUETmbbWPPmYOloTdSSr65DE76Qf2DJ4hf/yPh/2pnOpKIeBHLtm2P/2uWmppKaGgoKSkpGl8vIoWzZg20akV6Gaj6MmSWMR1IfMG3E+DmP+CXZzpxzfDZpuOIiAcobM/VG84i4ptyht7ENlChl9KTOwQnJHaJ6Sgi4mVU6kXEN+WU+tyzfYqUhrk589U32ZVC8u5tpuOIiBdRqRcR37NjB2zezEk/WNDAdBjxJQdCYVUE+Nmwfdy7puOIiBdRqRcR3zN3LgBLa0NyWdNhxNfkDsEpM+8b01FExIuo1IuI78kZejNXQ2/EgNmNnZeXb4on82ii6Tgi4iVU6kXEtyQkYP/yC/xtfLNIadpWFbZfBEHZsGXCe6bjiIiXUKkXEd/y9ddYts3qCNgfajqM+CTr9AHaJ2dNN51GRLyESr2I+JacoTfzGlmmk4gPyx1X33jVbhwnjpuOIyJeQKVeRHxHWhr2d98BMKuRx593TzzYqovhYAWomGmzffoo03FExAuo1IuI71i0CCszkx1VYEs102HEl9l+pw/UTpk63nQcEfECKvUi4jtyh940tkCjb8Sw3CE4dX/8DRwO03FExMOp1IuIbzh5Env+fABmNdTQGzFvSW1ICYLqqdnsWTTVdBwR8XAq9SLiG5YuxUpJIaE8rLjEdBgROBkA3+Sc0Tj+S42rF5ELo1IvIr4hZ+jN/EYWDv3mEzeROwSnxncrwdY7SCJSdPrTJiLez+HAnjsXNPRG3Exsfcj0h1qHMzm8ZpnpOCLiwVTqRcT7rV2LdeAA6WUgro7pMCKnpQXDd3Wd63vGDTMdR0Q8mEq9iHi/nKE3sQ0gs4zpMCL55Q7BCV24xHQUEfFgKvUi4v1ySv3sRqaDiJxtXkNwAA13p5K2c4vpOCLioVTqRcS7/f47bNnCST9Y0MB0GJGzHa4Av9R0rm8f+67pOCLioVTqRcS75Rwgu7Q2JJc1HUakYLlDcAK//sZ0FBHxUCr1IuLdcobezG2kU8iK+8ot9U02HyYzMd50HBHxQCr1IuK94uOxly8HYK6mshQ3tusi2FQdAhywffx7puOIiAdSqRcR7/X111i2zeoI2B9qOozI+eXurT81a4bpKCLigVTqRcR75Qy9maehN+IBcmdnarhmD45jGabjiIiHUakXEe+Ulob93XcAzGqkoTfi/tbXgL0hUP4kbP/qY9NxRMTDqNSLiHeKjcXKymJHFdhSzXQYkUKwTg/BSZ/+pek0IuJhVOpFxDvlznrT2AKNvhEPMbux87LeT1uwT540HUdEPIhKvYh4n6ws7G+c833P0qw34kF+vBSOlIUqGQ72fDPJdBwR8SAq9SLifZYtw0pJIb48rLzEdBiRwsv2h68vc64fnjzadBwR8SAq9SLifWbPBuCbRhYO/ZYTD5M7rv6S79eArXeaRKRw9OdORLyLw4GdM55+hma9EQ/0bT04FgAXH8ki/qdFpuOIiIdQqRcR77JyJdahQ6QEwfd1TIcRcd3xQFhU37n+5/gPTccREQ+hUi8i3mXWLAAWXGaRFWA6jEjR5A7BqfLtj6ajiIiHUKkXEe9h23mlfqaG3ogHm38ZnLKgwb4M/tqyznQcEfEAKvUi4j02boQ//uB4AMTWNx1GpOiOloMfajnXd4x5x3QcEfEAKvUi4j1yZr35tj5kBJkOI3JhcofglPvmW9NRRMQDqNSLiPfIGXozq5HpICIXbm7O93Hj7UfJ2L/bdBwRcXMq9SLiHXbsgE2bOGWdPnmPiCfbWwnW1gB/G7aO0xAcETk/lXoR8Q45Q2+W1IG/ypkOI1I8cofg+M2ZazqKiLg5lXoR8Q45pX5OY8t0EpFik1vqm/x6kMzkI6bjiIgbU6kXEc934ACsWIHDglmaylK8yG/VYWdlCD4FW778wHQcEXFjRSr1I0aMoHbt2gQHB9O6dWtWrVp1zm1Hjx5Nu3btqFy5MpUrVyYqKuqs7W3bpl+/ftSoUYOyZcsSFRXFjh07ihJNRHzRnDkALL8E4iuaDiNSjKzTe+szZ0wxnUZE3JjLpX7q1KnExMTQv39/1q1bR/PmzYmOjubw4cMFbr906VLuv/9+lixZwvLly6lZsya33HILBw4cyNtm6NChfPTRR4waNYqVK1dSvnx5oqOjOXHixIU9OxHxDTmz3szV0BvxQrMbOy8br/yD7Ez9XRSRglm2bbv0XnXr1q1p1aoVH3/8MQAOh4OaNWvy7LPP0qdPn3+8f3Z2NpUrV+bjjz+ma9eu2LZNREQEL7zwAi+++CIAKSkphIWFMW7cOO67775/fMzU1FRCQ0NJSUkhJCTElacjIp7uyBHssDCs7GzqPQd/VDEdSKR4+Tng4HsQlgGbvnyfpg/+n+lIIlKKCttzXdpTn5WVxdq1a4mKijr9AH5+REVFsXz58kI9xrFjxzh58iRVqjj/8u7evZv4+Ph8jxkaGkrr1q0L/Zgi4sO+/horO5sNYSr04p0cfjCvoXM95auxpuOIiJtyqdQnJSWRnZ1NWFhYvuvDwsKIj48v1GO88sorRERE5JX43Pu58piZmZmkpqbmW0TER+UMvZnTRMf9i/eamTMEp8EPm7FPnTIdR0TcUKn+FRw8eDBTpkxh9uzZBAcHF/lxBg0aRGhoaN5Ss2bNYs0pIh4iLQ37228BmNHIYTqNSIn5vg4kB0FYmoPfvx5nOo6IuCGXSn3VqlXx9/cnISEh3/UJCQmEh4ef977vvvsugwcP5ttvv6VZs2Z51+fez5XH7Nu3LykpKXnLvn37XHkaIuItFi7EysxkRxXYXN10GJGSczLg9BCcpC8/NR1HRNyQS6U+MDCQFi1aEBcXl3edw+EgLi6ONm3anPN+Q4cO5c033yQ2NpaWLVvmu61OnTqEh4fne8zU1FRWrlx5zscMCgoiJCQk3yIiPij3hFNNLNDEN+LlZjRxXtb9fj049M6UiOTn8vCbmJgYRo8ezfjx49m6dSu9evUiIyODHj16ANC1a1f69u2bt/2QIUN4/fXXGTNmDLVr1yY+Pp74+HjS09MBsCyL3r1789ZbbzFv3jw2bdpE165diYiIoFOnTsX5XEXEm5w4gT1/PgAzdMIp8QHf1oO0QKiRnM3ub6eZjiMibibA1Tt06dKFxMRE+vXrR3x8PJGRkcTGxuYd6Lp37178/E7/rzBy5EiysrK455578j1O//79GTBgAAAvv/wyGRkZPP744yQnJ9O2bVtiY2MvaNy9iHi5uDis9HT2V4TVEabDiJS8zDLwTQO4bzMcGj+COh3+ecpnEfEdLs9T7440T72ID3r0URgzhhGtLZ7p6PG/xkQK5e7NMGM67KtahpqHM8HSuDMRb1ci89SLiLiFU6ew584FDb0RH7OwARwLgJpJJ9n3w3zTcUTEjajUi4jn+eknrCNHSCoLP15qOoxI6TkWCLH1nev7xwwzHUdE3IhKvYh4nhkzAJjfyCLb33QYkdI1M2cWnPBvfzEdRUTciEq9iHgWhwN75kwApjXW0BvxPfMvg0x/qBN/gvhV35uOIyJuQqVeRDzLzz9jxceTHATf1TUdRqT0pQbD4pzv/T2fv2s6joi4CZV6EfEsOUNv5jWyOOnypLwi3iF3CM5FC5eZjiIibkKlXkQ8h8OBnVPqpzXR0BvxXXMbwkk/aLD/GIkbNLZeRFTqRcSTrFiBdfAgKUGwuJ7pMCLm/FUOltR2ru/6fKjpOCLiBlTqRcRzTJ8OwNcNLbI09EZ8XO4QnErf6GBZEVGpFxFP4XDkjafX0BsRmNMIsi1otCeNpK1rTccREcNU6kXEM6xaBfv3kxoI32rojQiHK5w++dqO0UNMxxERw1TqRcQz5J5wqqFFZhnTYUTcQ+4QnIpff2s6iogYplIvIu7PtvNK/XQNvRHJM6ux8/KKnSkc3fWb6TgiYpBKvYi4v9Wr4c8/SS8DsfVNhxFxHwdD4JdLnOvbRg8yHUdEDFKpFxH3l7OX/puGFic09EYkn9whOOXnLjAdRUQMUqkXEfdm23lTWWrWG5GzTc8p9U23J/PXrs2m44iIISr1IuLe1q2DPXvIKAMLNfRG5Cz7KjmH4PjZsO2zt03HERFDVOpFxL3l7KVfcBkcDzQdRsQ9TbvceVlxtobgiPgqlXoRcV9/n/WmsekwIu5r+uXgAK7YkUzyjk2m44iIASr1IuK+NmyAXbs4FgDfXGY6jIj7OhgCP+WciOqP0UNNxxERA1TqRcR95eylX3gZHNPQG5Hzyh2Cc/HCn01HEREDVOpFxD3ZNkybBhp6I1IoM5pAtgVhv+2GPXtMxxGRUqZSLyLuad062LmTYwEwX0NvRP5RQkVYVivng5wDzEXEd6jUi4h7mjoVgPkNLTKCTIcR8Qy5Q3Byf35ExHeo1IuI+3E48krJV1fohFMihTWzCTj8/WDtWti503QcESlFKvUi4n5WrIC9e0kN1AmnRFyRVB4Otmzo/EBDcER8ikq9iLifKVMAmNvYIrOM6TAinuWPm1s6VzQER8SnqNSLiHvJzsbOmfXmq8s19EbEVXuu/xcEBMCvv8L27abjiEgpUakXEfeybBlWQgJHysJ3dU2HEfE8mZUqQFSU84Ocf5BFxPup1IuIe8kZMjC7icXJANNhRDxUly7OSw3BEfEZKvUi4j5OnsTOOYvsZA29ESm6Tp2gTBnYvNm5iIjXU6kXEffx3XdYR48SXx6W1TYdRsSDVaoE0dHOdQ3BEfEJKvUi4j5yZr2ZeYWFQ7+dRC7M34fg2HrnS8Tb6c+miLiHEyewZ88GDb0RKR533AFBQc4ZcDZsMJ1GREqYSr2IuIeFC7HS0tgbAssvMR1GxAuEhMC//+1cnzTJdBoRKWEq9SLiHnKG3kxvamHrN5NI8XjwQeflV19BdrbpNCJSgvSnU0TMy8jAnj8fNPRGpHh17Og8aPbgQfjhB9NpRKQEqdSLiHnz5mEdO8bOyrCuhukwIl4kKAjuuce5Pnmy6TQiUoJU6kXEvC+/BGBqUwss02FEvEzuEJwZMyAz03QaESkhKvUiYlZiIvaiRQBMaKahNyLF7rrr4OKLITkZFi40nUZESohKvYiYNXUqVnY2qyLg96qmw4h4IT8/uP9+57pmwRHxWir1ImJWztCbr5pp3I1IickdgvP115CSYjqNiJSAIpX6ESNGULt2bYKDg2ndujWrVq0657abN2/m7rvvpnbt2liWxbBhw87aZsCAAViWlW9p1KhRUaKJiCfZsQNWruSUH0y+QkNvREpM8+bQuLFzTH3OSd5ExLu4XOqnTp1KTEwM/fv3Z926dTRv3pzo6GgOHz5c4PbHjh2jbt26DB48mPDw8HM+7uWXX86hQ4fylp9++snVaCLiaXJm41hcFw5XMB1GxItZ1um99RqCI+KVXC7177//Pj179qRHjx40adKEUaNGUa5cOcaMGVPg9q1ateKdd97hvvvuIygo6JyPGxAQQHh4eN5StaoG14p4NdvOG3ozqZnpMCI+IHdc/fffw6FDptOISDFzqdRnZWWxdu1aoqKiTj+Anx9RUVEsX778goLs2LGDiIgI6taty4MPPsjevXvPuW1mZiapqan5FhHxMKtWwc6dpJeB2RptJ1Ly6taFNm3A4YCpU02nEZFi5lKpT0pKIjs7m7CwsHzXh4WFER8fX+QQrVu3Zty4ccTGxjJy5Eh2795Nu3btSEtLK3D7QYMGERoamrfUrFmzyJ9bRAzJ2Us/t7HFsUDTYUR8RO4QHJ2ISsTruMXsNx07duTee++lWbNmREdHs2DBApKTk5k2bVqB2/ft25eUlJS8Zd++faWeWUQuwMmT2FOmADCxqQ6QFSk1994L/v6werXzQHUR8RoulfqqVavi7+9PQkJCvusTEhLOexCsqypVqsRll13Gzp07C7w9KCiIkJCQfIuIeJDFi7GSkkgoD9/VNR1GxIdUrw633OJcz3m3TES8g0ulPjAwkBYtWhAXF5d3ncPhIC4ujjZt2hRbqPT0dHbt2kWNGjWK7TFFxI3klImpTS2y/U2HEfExDz3kvJw40XnAuoh4BZeH38TExDB69GjGjx/P1q1b6dWrFxkZGfTo0QOArl270rdv37zts7Ky2LBhAxs2bCArK4sDBw6wYcOGfHvhX3zxRZYtW8aePXv45Zdf+M9//oO/vz/35x6pLyLeIy0Ne84cACZo6I1I6evUCSpWhN27QdNHi3iNAFfv0KVLFxITE+nXrx/x8fFERkYSGxubd/Ds3r178fM7/b/CwYMH+de//pX38bvvvsu7775L+/btWbp0KQD79+/n/vvv58iRI1SrVo22bduyYsUKqlWrVjzPUkTcx+zZWMePs/0iWBthOoyIDypXzjm2fswYGD8e2rUznUhEioFl257/3ltqaiqhoaGkpKRofL2Iu4uOhm+/pf8NfrzR3mE6jYjX+ez2z+jZouf5N/rhB2jf3rnHPj7eWfRFxC0Vtue6xew3IuIjDhzA/u47ACY2VaEXMaZtW6hdG9LSIGc4nIh4NpV6ESk9EydiORwsqwW7q5gOI+LD/Pyga1fn+oQJptOISDFQqReR0mHbMHYsABMiLdNpRCS31C9eDAcPmk4jIhdIpV5ESseKFfD772SUgWlNPP5QHhHPV6+ecxiOw6E560W8gEq9iJSOceMAmNnEIj3IdBgRgb/trR8/XnPWi3g4lXoRKXnHj2NPmQLAmEgVBxG30bkzBAfDli2wbp3pNCJyAVTqRaTkzZ6NlZrK7krwQy3TYUQkT2io82RU5OytFxGPpVIvIiUvZ+jNxEgLW791RNxL7hCcyZMhK8t0GhEpIv15FZGStW9f3tz045pp6I2I27n5ZggPhyNH4JtvTKcRkSJSqReRkjVxIpZts1Rz04u4p4CA03vrv/jCdBoRKSKVehEpOZqbXsQzPPKI83LhQjhwwHQaESkClXoRKTm//AI7d5KuuelF3FvDhtCunXPOeh0wK+KRVOpFpOTk7KWfcblFhuamF3Fvjz7qvPziC2e5FxGPolIvIiUjLU1z04t4knvugYoV4Y8/YNky02lExEUq9SJSMqZMwcrIYNtF8KPmphdxf+XLwwMPONd1wKyIx1GpF5GSMXo0AGNaWKBjZEU8Q+4QnBkz4K+/TKcREReo1ItI8fv1V1i9miw/GNtcQ29EPEbLltC0KWRmOk9GJSIeQ6VeRIpfzl76uY0hqbzpMCJSaJYFjz3mXNcQHBGPolIvIsXr2DHsL78E4LMrTYcREZc9+CAEBsL69bBunek0IlJIKvUiUrymT8dKSeGPShBXx3QYEXHZRRfBXXc517W3XsRjqNSLSPHKGXoztoUftn7DiHim3ANmJ02CY8dMpxGRQtCfXBEpPlu2wM8/c8oPvmiuk9eIeKwbb4Q6dSAlBaZNM51GRApBpV5Eis/nnwPwzWVwKMR0GBEpMj8/eOIJ5/rIkabTiEghqNSLSPHIzMSeMAF0gKyId+jRA8qUgVWrdMCsiAdQqReR4jF7NtaRI+wLgdj6psOIyAWrXh3uuce5rr31Im5PpV5EiscnnwAw9koLh36ziHiHXr2cl5MnO8fXi4jb0p9eEblwmzbBjz9yyg9GXakzyIp4jbZt4fLLnTPgTJxoOo2InIdKvYhcuJy99HMa6QBZEa9iWfDkk871kSPB1j/tIu5KpV5ELkxKCnbOHryPW5kOIyLF7uGHoVw555S1P/1kOo2InINKvYhcmAkTsDIy2FwNltU2HUZEil1oKDz4oHNdB8yKuC2VehEpOtvOG3ozqpUFlulAIlIicofgzJgBhw+bTiMiBVCpF5GiW7IEtm0jLRDGN9NYWxGvdeWVcNVVcPIkjBljOo2IFEClXkSKbsQIAL5sbpEWbDqMiJSo3OktR42C7GzTaUTkDCr1IlI0+/djz50LwMettJdexOt16QIXXQR//gnz5plOIyJnUKkXkaL57DOs7GyW1oIt1U2HEZESV7YsPP64c/3DD02nEZEzqNSLiOuysrBHjwbgk6tMhxGRUvPUU+DvD8uWwYYNptOIyN+o1IuI62bMwIqP52AFmN3IdBgRKTWXXAL33ONc/+gj02lE5G9U6kXENbYNH3wAwKirLE75mw4kIqXq+eedl5MnQ2Ki6TQikkOlXkRc8/PPsGYNxwPgkxY6QFbE51x9NbRqBZmZ8OmnptOISA6VehFxzbBhkDON5ZHypsOISKmzrNN76z/5BLKyTCcSEZV6EXHJ7t3Ys2cDMKy19tKL+Kx774UaNeDQIZg503QaEVGpFxGXDB+O5XCwqJ6msRTxaYGBp09GpektRdxCkUr9iBEjqF27NsHBwbRu3ZpVq1adc9vNmzdz9913U7t2bSzLYljOW/cX8pgiYkBqKvbnnwMw7GrTYUTEuMcfd5b7lSudi4gY5XKpnzp1KjExMfTv359169bRvHlzoqOjOXz4cIHbHzt2jLp16zJ48GDCw8OL5TFFxICxY7HS0thaFRbVMx1GRIwLC4P773eu58yIJSLmuFzq33//fXr27EmPHj1o0qQJo0aNoly5cowZM6bA7Vu1asU777zDfffdR1BQULE8poiUsuzsvDmph19tYWvgnogAxMQ4L6dPh927TacR8Wku/WnOyspi7dq1REVFnX4APz+ioqJYvnx5kQIU5TEzMzNJTU3Nt4hICZo9G/74gyNlYVwzHSArIjmaNYPoaHA44P33TacR8WkulfqkpCSys7MJCwvLd31YWBjx8fFFClCUxxw0aBChoaF5S82aNYv0uUWkEGwbhg4FYORVFscDTQcSEbfy0kvOyy++gKQk02lEfJZHvonet29fUlJS8pZ9+/aZjiTivZYuhdWrOR4AH7XSXnoROcONN8KVV8Lx485560XECJdKfdWqVfH39ychISHf9QkJCec8CLYkHjMoKIiQkJB8i4iUkCFDABj7L4vECqbDiIjbsazTe+s//thZ7kWk1LlU6gMDA2nRogVxcXF51zkcDuLi4mjTpk2RApTEY4pIMfn1V1i0iGwL3m2jvfQicg733AO1a0NiIowfbzqNiE9yefhNTEwMo0ePZvz48WzdupVevXqRkZFBjx49AOjatSt9+/bN2z4rK4sNGzawYcMGsrKyOHDgABs2bGDnzp2FfkwRMSRnLP30y2F3FdNhRMRtBQScngnn3XedM2aJSKkKcPUOXbp0ITExkX79+hEfH09kZCSxsbF5B7ru3bsXP7/T/yscPHiQf/3rX3kfv/vuu7z77ru0b9+epUuXFuoxRcSAPXuwp07FAoZcazqMiLi9Rx6BAQNg1y7njFn33GM6kYhPsWzb9vj31FNTUwkNDSUlJUXj60WKy7PPwscf821diO5qOoyIFNZnt39GzxY9zXzyfv3gzTedB86uWeMcby8iF6SwPdcjZ78RkRKWmIj9xRcADGlrOoyIeIznnoPy5WHdOoiNNZ1GxKeo1IvI2d5/H+v4cVZHwPd1TIcREY9RtSr06uVcf/NN53kuRKRUqNSLSH5Hj2J//DEAb10H6N1zEXHFCy9AUBAsXw5LlphOI+IzVOpFJL9hw7DS09kQBvMamg4jIh4nPBx65ozpf+st02lEfIZKvYiclpyM/eGHAPyvvaW99CJSNC+9BGXKOPfU//yz6TQiPkGlXkROGz4cKzWV36rBzEYaCysiRXTppdCtm3Nde+tFSoVKvYg4paZif/ABAG+3t7D120FELkSfPuDv75wFZ80a02lEvJ7+bIuI0yefYP31F9sugqlNtJdeRC5QvXrwwAPO9YEDTacR8Xoq9SIC6enY770HwKD2Fg79ZhCR4vDaa+DnB/Pnw4oVptOIeDX96RYR+PBDrKQkdlSBSZdrL72IFJPLLjs9tr5fP9NpRLyaSr2Ir/vrL+x33gFg4A0W2f6mA4mIV3n9dQgIgMWL4YcfTKcR8Voq9SK+7p13sFJS2FQdJmsvvYgUtzp14LHHnOuvvaazzIqUEJV6EV+WkJA3L/3rN6IZb0SkZPz3v86zzP74I3z3nek0Il5Jf8JFfNmgQVjHjrHyYpirs8eKSEm55BJ48knnuvbWi5QIlXoRX7V3L/bIkZCzl15njxWREtWnD5QrB6tWOWfDEZFipVIv4qvefBMrK4ultWBxXdNhRMTrhYfDs8861/v0gVOnTCcS8Soq9SK+aNs27LFjAfjvTdpLLyKlpE8fqFIFtmyB8eNNpxHxKir1Ir7olVewsrP5uiH8cqnpMCLiMypVco6pJ2fe+owM04lEvIZKvYivWboU5s3jlB+8HGU6jIj4nKeeck5zefAgfPCB6TQiXkOlXsSXOBzw4osAjG5hsa2a6UAi4nOCguDtt53rQ4bA4cOmE4l4BZV6EV8yZQqsXUtqIPRvrynlRMSQzp2hZUtIT4c33jCdRsQrqNSL+IoTJ6BvXwCGtrNIrGA6kIj4LD8/GDrUuf7pp/D776YTiXg8lXoRX/HRR7B3L/tC4P3W2ksvIobdcAPcdptzasucYYEiUnQq9SK+ICEB+3//A+D1myyOB5oOJCICvPsuBATA119DbKzpNCIeTaVexBf07YuVmsqaGjChqfbSi4ibaNQInnvOud67N2RlmU4k4rFU6kW83YoVkHOiqWduBVs/9SLiTvr1g+rVYft2GD7cdBoRj6U/7yLeLDsbnnkGgHGRFitrmg4kInKG0FAYNMi5PnAgxMebTiTikVTqRbzZmDGwdi0pQfBKlIbdiIib6t7dOcVlWhq8+qrpNCIeSaVexFsdPYqdM4XlwBssDmsKSxFxV35+p4fejB0LK1eaTiTicVTqRbxVv35YR47wWzUY3kp76UXEzV19NXTt6lx/8knnVJciUmgq9SLeaPVq7JEjAXjuVjjlbzqQiEghvPMOVK4MGzY4z60hIoWmUi/ibU6ehJ49sRwOJjWzWFLHdCARkUKqXt1Z7AFefx3+/NN0IhGPoVIv4m3efx9+/ZUjZaF3tIbdiIiH6dED2rWDY8fg6afB1u8xkcJQqRfxJrt2YQ8YAMCLHSySypsOJCLiIj8/+PRTKFMGvvkGZs0ynUjEI6jUi3gL24YnnsA6cYLv6sC4Ztq7JSIeqnFj6NPHuf7ss5CSYjqRiNtTqRfxFhMnQlwcxwPgydsBy3QgEZEL8Oqr0KABHDoEL71kOo2I21OpF/EGhw5h/9//AfDGDX7sush0IBGRCxQcDKNHO9dHj4ZFi0wnEnFrKvUins62nbPdHD3K2hrw7tUO04lERIpH+/bw3HPO9UcfheRk04lE3JZKvYinGzMGvvmGTH/o+h/NSS8iXubtt6F+fThwAHLekRSRs6nUi3iyPXuwe/cGoN9NfmypbjqQiEgxK18exo4Fy4Jx42D+fNOJRNySSr2Ip3I4oEcPrPR0frxUw25ExIu1bXt6L33PnnD0qOlEIm6nSKV+xIgR1K5dm+DgYFq3bs2qVavOu/306dNp1KgRwcHBNG3alAULFuS7vXv37liWlW/p0KFDUaKJ+I7hw2HpUjLKQPdO4NC/6CLizd56Cy67DOLj4fHHdVIqkTO4XAOmTp1KTEwM/fv3Z926dTRv3pzo6GgOHz5c4Pa//PIL999/P48++ijr16+nU6dOdOrUid9++y3fdh06dODQoUN5y1dffVX0ZyXi7TZuxH7lFQBevsXijyqmA4mIlLCyZWHSJAgIgJkzT8+MIyJQlFL//vvv07NnT3r06EGTJk0YNWoU5cqVY8yYMQVu/+GHH9KhQwdeeuklGjduzJtvvsmVV17Jxx9/nG+7oKAgwsPD85bKlSsX/VmJeLOMDOjSBSszkwUN4JOW2lslIj6iZUvngbMAvXvDli2mE4m4DZdKfVZWFmvXriUqKur0A/j5ERUVxfLlywu8z/Lly/NtDxAdHX3W9kuXLqV69eo0bNiQXr16ceTIEdeeiYivePZZ2LaNAxWhWyedZEpEfMwLL8DNN8Px43DffXDihOlEIm7BpVKflJREdnY2YWFh+a4PCwsjPj6+wPvEx8f/4/YdOnRgwoQJxMXFMWTIEJYtW0bHjh3Jzs4u8DEzMzNJTU3Nt4j4hEmTYOxYsi146C5IKm86kIhIKfPzgwkToFo12LRJZ5sVyeEWh9bdd9993HHHHTRt2pROnToxf/58Vq9ezdKlSwvcftCgQYSGhuYtNWvWLPXMIqVuxw7sJ58E4H/tLZbWMR1IRMSQ8HAYP965/vHHMGuW6UQixrlU6qtWrYq/vz8JCQn5rk9ISCA8PLzA+4SHh7u0PUDdunWpWrUqO3fuLPD2vn37kpKSkrfs27fPlach4nmOH3eOo09PZ1kteKOdxtGLiI/r2BFiYpzr3bvD9u2mE4kY5VKpDwwMpEWLFsTFxeVd53A4iIuLo02bNgXep02bNvm2B1i8ePE5twfYv38/R44coUaNGgXeHhQUREhISL5FxGvZtnP6tvXrSSwHD94F2TprrIgIDB4M110HaWlw112Qnm46kYgxLg+/iYmJYfTo0YwfP56tW7fSq1cvMjIy6NGjBwBdu3alb9++eds///zzxMbG8t5777Ft2zYGDBjAmjVreOaZZwBIT0/npZdeYsWKFezZs4e4uDjuvPNO6tevT3R0dHE+VxHPNHw4fPklp/ygy71wINR0IBERN1GmDEydCjVqOGfCefRRzV8vPivA1Tt06dKFxMRE+vXrR3x8PJGRkcTGxuYdDLt37178/E7/r3DNNdcwefJkXnvtNV599VUaNGjAnDlzuOKKKwDw9/dn48aNjB8/nuTkZCIiIrjlllt48803CQoKKs7nKuJ5li3DjonBAvrc4seSOjprrIhIPuHhMGMGtG8P06ZB69anh+WI+BDLtj3/X9rU1FRCQ0NJSUnRUBzxHvv2YbdogZWYyKRm8NB/NH2liPyzz27/jJ4tepqOUfo+/tg55a+/PyxaBDfdZDqRSLEobM91i9lvROQMGRlw111YiYmsD4eet6vQi4ic19NPw8MPQ3Y23H03bN1qOpFIqVKpF3E32dnw4IOwZg2J5eA/XeB4oOlQIiJuzrLgs8/gmmsgJQVuvx2SkkynEik1KvUi7uaFF2DuXE4EQKf74M/KpgOJiHiI4GCYMwfq1IE//oBOnSAz03QqkVKhUi/iTj76CD78EIBud/nxy6WmA4mIeJhq1eCbbyA0FH7+WTPiiM9QqRdxF/PmYffuDUDfKItpTTTTjYhIkTRu7JwRx98fJk2Cv021LeKtVOpF3MGyZdhdumDZNqNbWAy+VnuVREQuSFSUc4w9wJAh8M47phOJlCiVehHTVq/Gvv12rBMnmH8ZPHWrrZluRESKwyOPwNChzvWXX4YvvjCdSKTEqNSLmLR5M3aHDljp6XxfG+65F075mw4lIuJFXnrJWegBHn8cZs0ynUikRKjUi5jyxx/YN9+MdfQoKy+GO++HzDKmQ4mIeKHBg+Gxx8DhgPvvhwULTCcSKXYq9SIm7NqFfcMNWIcOsak6dHwQ0oNMhxIR8VKWBaNGwb33QlYW/Oc/MH++6VQixUqlXqS0bd+O3b491t69bL8IbnkY/ipnOpSIiJfLnQnnnnucxf6uu2DePNOpRIqNSr1Iadq82VnoDxxgczVo3x3iK5oOJSLiI8qUgcmToXNnOHnSWfDnzDGdSqRYqNSLlJZff8W+/nqshAQ2hMH13SFBhV5EpHSVKePcY3/ffc5if++9zo9FPJxKvUhpWLIE+7rrsJKSWFMDbuwGSeVNhxIR8VEBATBxIjz4IJw6BQ89BB98YDqVyAVRqRcpaVOmOKetTE3lx0shqqvG0IuIGBcQABMmQM6ZvImJgVdeAVsn/xPPpFIvUpLefx/uvx8rK4sZTeDmhyGlrOlQIiICgJ+f8/f0kCHOj4cOhe7dnQfSingYlXqRknDyJDz3HLzwAgAftbboco/moRcRcTuW5Tw51bhxzhlyJkyAqChITDSdTMQlKvUixS0pCaKjYfhwAF6+xY/nO9g49NMmIuK+unVzzl0fEgI//gitWsHGjaZTiRSaaoZIcfr1V+cfgiVLSAuEu+6zeOcaB1img4mIyD/q0AFWroT69eHPP+Gaa2D2bNOpRApFpV6kuHz1FfY118CePeysDFc/BrMb6YArERGP0qiRs9hHRUFGhvMkVS+/7BxWKeLGVOpFLlRGBjz2GDzwANaxY3xbF67qCVuqmw4mIiJFUqUKLFx4emacd96B9u1h717TyUTOSaVe5EJs2uQcbvPFFzgsePs6i1sf1JSVIiIeLyDAOXf9zJkQGgrLl8O//uUcdy/ihlTqRYrC4YDhw7Gvugq2buVQBed0lf+90Sbb33Q4EREpNnfdBevWQcuWcPQo/Pvf8MQTkJZmOplIPir1Iq7atQtuvBGeew7rxAkW1IfmT8L3dU0HExGRElG3Lvz00+nhOJ99Bs2awdKlppOJ5FGpFyms3L3zzZrBsmVklIHnbrW4/QFIrGA6nIiIlKigIOdwnO+/h1q1YM8euOEG5zlJtNde3IBKvUhhrFsH117r3Dt/7BhLakPTXjD8KhtbP0UiIr7jhhucx1P17On8ePhw54w506eDrRnPxBzVEZHz+esvePpp7JYtYcUK0gLhmdssbuoKu6uYDiciIkZUrOgcgrNoEdSrBwcPQufO0LEj7NxpOp34KJV6kYKcPAmjRmFfdhl88gmWbfNVU2j4DIxopb3zIiIC3HKLc699v34QGOgs+U2aQEyM86BakVKkaiLyd7YNM2bA5ZdDr15YSUlsrgY3doMH7oZDIaYDioiIWylbFgYOdJb7W25x7hT64APnHvz33oPMTNMJxUeo1IuQU+a//RauvhruvRd27OBwOXi+o0Xkk7CkjumAIiLi1i67DGJjnSetuuIKSE6GF190Xj9qlMq9lDiVevFttg3z5kHr1hAdDatWkV4G3rjeot7z8FFrm1Oad15ERArDsqBDB9iwAb74AiIinGeh7dULGjSATz5RuZcSo1IvvikzEyZMgMhIuPNOWL2aYwHw0dUW9Z+D/tfbpAeZDikiIh7J3x8eecR50OyHH0KNGrBvHzz9NNSuDW+9BYmJplOKl1GpF99y4AC8/jr2pZdCt26wcSOpgTCknUXt3vB8B5uEiqZDioiIVyhb1jmP/R9/wMcfwyWXQHw8vP46XHqpc1rM334znVK8hEq9eL/sbOd4+fvuw87ZQ2IdPsy+EHjtJmeZ73OTrRNIiYhIyQgOdu6l37ULJk2Cli3hxAn4/HNo2hTat4fx4yEjw3RS8WAq9eK9tm+HV191nvkvOhqmTsU6dYofLoXO90Ld5+F/7Wz+Kmc6qIiI+ITAQHjgAVi1Cn76Ce65B/z84IcfoHt3CA937r3/5RedyEpcFmA6gEix2rULZs50Tku5enXe1UeDYWpTi8+utNlQw2hCERHxdZblPEv5tdc6x9pPmABjxzr/hn3+uXOpVctZ+jt3hlatnPcROQ/Ltj3/X8HU1FRCQ0NJSUkhJEQTifsU24aNG50z2MycCb/+mnfTKQsWNYCxzeHrhpClf2FFxAd8dvtn9GzR03QMcZVtw48/wpgxMH06HDt2+rZateDuu+G226BtW+cef/EZhe25KvXieRITYfFiWLQI+9tvseLj8246ZcHS2jC7icXMRjroVUR8j0q9Fzh2zDnf/YwZ8PXX+cfaV6gAUVFw663Ok13VqmUyqZSCwvZc7bsU93foEPz8s3P84Y8/wrp1eTdZQEYZWFoHZjWCuQ3hSHkAj/9fVUREfFW5cs4983ffDcePO09qNW+es+gnJMCcOc6FnL347dvDddc5L+vV01AdH6VSL+4lI8M5hGb9eli50lnm//jjrM02hMHiBhaxdW1+ulRDa0RExEuVLQv/+Y9zcTicfx8XLoQFC5wH3P75p3NM/oQJzu0jIpwnVGzZ0rm0aAEXXWT6WUgpUBUSMxwO55zxW7c6z7y3fj2sX4/9++9YZ4wIcwAbw+CXWhY/1rRZUpucYTXaGy8iIj7Ez89Z0lu0gNdeg/R0WL4cli1zzqCzciUcPAizZzuXXHXqwJVXwuWXn14aNNDYfC+jUi8lx7bh8GHnXoQ//nBOMbltG2zfjr19O9bfDwLKYQGHKsCGGrA2wlniV1wCqcGoxIuIiPxdhQpw883OBZxDddascc7+tmaNc9mxA3bvdi4zZ56+b0CAs9hffjnUrw91655eatZ03i4epUhfsREjRvDOO+8QHx9P8+bNGT58OFddddU5t58+fTqvv/46e/bsoUGDBgwZMoRbb70173bbtunfvz+jR48mOTmZa6+9lpEjR9KgQYOiPSspeadOOQ9YjY93LgkJzj3vf/4Je/bAn39i792LdeJEgXe3gJN+sKsy/BZusT4c1oXbrA/nbwe3qsSLiIgUWtmy0K6dc8mVnAxr1zqHtm7e7Fy2bIG0NOe75Vu3nv04/v7Osfp16jgLfkTE2Ut4OJQpU6pPT87P5VI/depUYmJiGDVqFK1bt2bYsGFER0ezfft2qlevftb2v/zyC/fffz+DBg3i9ttvZ/LkyXTq1Il169ZxxRVXADB06FA++ugjxo8fT506dXj99deJjo5my5YtBAcHF88zlYJlZzuPsk9Ohr/+gqNHnZe5y98/PnIE4uOx4+MhKemsYTJnsnKGzhwIgT2VYGdViy0X2Wy/CLZVhd2V4ZQ/Ku8iIiIlpVIluOkm55LLtmH/fmfB37rV+W567rJ7N2Rmnv74XCwLqlaFatWcY/bPtVSpAhUrQkiI87JiRecZdnUwb7FzeUrL1q1b06pVKz7++GMAHA4HNWvW5Nlnn6VPnz5nbd+lSxcyMjKYP39+3nVXX301kZGRjBo1Ctu2iYiI4IUXXuDFF18EICUlhbCwMMaNG8d99933j5k8YkpLh8NZoLOznXu5c9fPteRuk5Xl/OHKzMy/XtDHZ16XkXF6SU/Pd2nnXFrHjxf5KWVbcLg8xFeAhAqQUNFid6jNnlD4sxL8GQr7Q+Ck3sETESk1mtJSLojD4Zx1LrfUHzx49nLoEJw8WfTP4e+fv+TnLuXKOQt/cLDzXYfzrZctC0FBzncLAgIKd3nmdQEBziyW5db/ZJTIlJZZWVmsXbuWvn375l3n5+dHVFQUy5cvL/A+y5cvJyYmJt910dHRzMmZimn37t3Ex8cTFRWVd3toaCitW7dm+fLlBZb6zMxMMjMz8z1Zo1q3xt6zBzv7VF4ht7JPl3grO9tsvgKc+a2b5Qd/lYWjZeGvYEgua5FcNue6IJsjObfFVzhd4pPKgcPv74+iPe4iIiIezc8PLr7Yufx9GM/fORzOd+8PHnRenmtJSnK+05+W5lzS0533z84+PQrAXViWs+D7+Z37cvx46NjRdNJzcqnUJyUlkZ2dTVhYWL7rw8LC2LZtW4H3iY+PL3D7+JwTBuVenm+bMw0aNIiBAwe6Er1E2UlJWIcPn1WUC8sBZPs593znXp7yc65n+UOmP2QG5F/P9M/5OODctx8rA+mBkBGYc3mej08EOJu+hYW/n3+hcvvlLCIi4h5OOU7hZ+k3s5QwPz/nsJtq1Vy7n8PhLPa5JT819fR6WprzQN8TJ5xLYdZPnHC+Y3DqVMGXZ1536tS5s9n2+W+HC3t3ohR45MCIvn375tv7n5qaSs2aNY3lsebPZ/qvXzFt20xsfz8c/n7Y/n5Y/gHYfn5YAQF5H+PvDwEBWAEBWP7OywD/Mvhb/gT4BRDgF0AZvzLOS/8yeR8H+gcS4BdQ6F/WFlA+ZxEREd8Q4BdAp0adTMcQKZifn3PYjamh0rnF/e9FP3d4tMORf72gSzc/e69Lpb5q1ar4+/uTkJCQ7/qEhATCw8MLvE94ePh5t8+9TEhIoEaNGvm2iYyMLPAxg4KCCAoKciV6yWrcmHsbv8G9vGE6iYiIiIgUxLJOj60vW9Z0mmLn0nt0gYGBtGjRgri4uLzrHA4HcXFxtGnTpsD7tGnTJt/2AIsXL87bvk6dOoSHh+fbJjU1lZUrV57zMUVERERE5DSXh9/ExMTQrVs3WrZsyVVXXcWwYcPIyMigR48eAHTt2pWLL76YQYMGAfD888/Tvn173nvvPW677TamTJnCmjVr+OyzzwCwLIvevXvz1ltv0aBBg7wpLSMiIujUSW8hioiIiIj8E5dLfZcuXUhMTKRfv37Ex8cTGRlJbGxs3oGue/fuxc/v9BsA11xzDZMnT+a1117j1VdfpUGDBsyZMydvjnqAl19+mYyMDB5//HGSk5Np27YtsbGxmqNeRERERKQQXJ6n3h15xDz1IiIiIiIuKmzP1bxXIiIiIiIeTqVeRERERMTDqdSLiIiIiHg4lXoREREREQ+nUi8iIiIi4uFU6kVEREREPJxKvYiIiIiIh1OpFxERERHxcCr1IiIiIiIeTqVeRERERMTDqdSLiIiIiHg4lXoREREREQ+nUi8iIiIi4uECTAcoDrZtA5Cammo6ioiIiIhIscntt7l991y8otSnpaUBULNmTdNRRERERESKXVpaGqGhoee83bL/qfZ7AIfDwcGDB6lYsSKWZZX6509NTaVmzZrs27ePkJCQUv/8nk6vX9HptSs6vXYXRq9f0em1Kzq9dhdGr1/RmXztbNsmLS2NiIgI/PzOPXLeK/bU+/n5cckll5iOQUhIiH5ILoBev6LTa1d0eu0ujF6/otNrV3R67S6MXr+iM/XanW8PfS4dKCsiIiIi4uFU6kVEREREPJxKfTEICgqif//+BAUFmY7ikfT6FZ1eu6LTa3dh9PoVnV67otNrd2H0+hWdJ7x2XnGgrIiIiIiIL9OeehERERERD6dSLyIiIiLi4VTqRUREREQ8nEq9iIiIiIiHU6kvIZmZmURGRmJZFhs2bDAdx2PccccdXHrppQQHB1OjRg0efvhhDh48aDqW29uzZw+PPvooderUoWzZstSrV4/+/fuTlZVlOppH+N///sc111xDuXLlqFSpkuk4bm/EiBHUrl2b4OBgWrduzapVq0xH8gg//PAD//73v4mIiMCyLObMmWM6kscYNGgQrVq1omLFilSvXp1OnTqxfft207E8wsiRI2nWrFneSZPatGnDwoULTcfySIMHD8ayLHr37m06SoFU6kvIyy+/TEREhOkYHueGG25g2rRpbN++nZkzZ7Jr1y7uuece07Hc3rZt23A4HHz66ads3ryZDz74gFGjRvHqq6+ajuYRsrKyuPfee+nVq5fpKG5v6tSpxMTE0L9/f9atW0fz5s2Jjo7m8OHDpqO5vYyMDJo3b86IESNMR/E4y5Yt4+mnn2bFihUsXryYkydPcsstt5CRkWE6mtu75JJLGDx4MGvXrmXNmjXceOON3HnnnWzevNl0NI+yevVqPv30U5o1a2Y6yrnZUuwWLFhgN2rUyN68ebMN2OvXrzcdyWPNnTvXtizLzsrKMh3F4wwdOtSuU6eO6RgeZezYsXZoaKjpGG7tqquusp9++um8j7Ozs+2IiAh70KBBRnN5GsCePXu26Rge6/DhwzZgL1u2zHQUj1S5cmX7888/Nx3DY6SlpdkNGjSwFy9ebLdv395+/vnnTUcqkPbUF7OEhAR69uzJxIkTKVeunOk4Hu3o0aNMmjSJa665hjJlypiO43FSUlKoUqWK6RjiRbKysli7di1RUVF51/n5+REVFcXy5cuNZhPfkpKSAqDfcS7Kzs5mypQpZGRk0KZNG9NxPMbTTz/Nbbfdlu93nztSqS9Gtm3TvXt3nnzySVq2bGk6jsd65ZVXKF++PBdddBF79+5l7ty5piN5nJ07dzJ8+HCeeOIJ01HEiyQlJZGdnU1YWFi+68PCwoiPjzeWS3yLw+Ggd+/eXHvttVxxxRWm43iETZs2UaFCBYKCgnjyySeZPXs2TZo0MR3LI0yZMoV169YxaNAg01H+kUp9IfTp0wfLss67bNu2jeHDh5OWlkbfvn1NR3YrhX39cr300kusX7+eb7/9Fn9/f7p27YqvnvjY1dcO4MCBA3To0IF7772Xnj17GstuWlFeOxFxf08//TS//fYbU6ZMMR3FYzRs2JANGzawcuVKevXqRbdu3diyZYvpWG5v3759PP/880yaNIng4GDTcf6RZftqW3JBYmIiR44cOe82devWpXPnznz99ddYlpV3fXZ2Nv7+/jz44IOMHz++FNK6n8K+foGBgWddv3//fmrWrMkvv/zik28VuvraHTx4kOuvv56rr76acePG4efnu/+3F+X7bty4cfTu3Zvk5ORSSOh5srKyKFeuHDNmzKBTp05513fr1o3k5GS9q+YCy7KYPXt2vtdR/tkzzzzD3Llz+eGHH6hTp47pOB4rKiqKevXq8emnn5qO4tbmzJnDf/7zH/z9/fOuy87OxrIs/Pz8yMzMzHebaQGmA3iCatWqUa1atX/c7qOPPuKtt97K+/jgwYNER0czdepUWrduXcIp3VdhX7+COBwOyJki1Be58todOHCAG264gRYtWjB27FifLvRc4PedFCwwMJAWLVoQFxeXV0YdDgdxcXE888wzpuOJF7Ntm2effZbZs2ezdOlSFfoL5HA4fPbvqituuukmNm3alO+6Hj160KhRI1555RW3KvSo1BevSy+9NN/HFSpUAKBevXpccsklhlJ5jpUrV7J69Wratm1L5cqV2bVrF6+//jr16tXzyb30rjhw4ADXX389tWrV4t133yUxMTHvtvDwcKPZPMHevXs5evQoe/fuJTs7O+/cEvXr18/7ORanmJgYunXrRsuWLbnqqqsYNmwYGRkZ9OjRw3Q0t5eens7OnTvzPt69ezcbNmygSpUqZ/39kPyefvppJk+ezNy5c6lYsWLeMRyhoaGULVvWdDy31rdvXzp27Mill15KWloakydPZunSpSxatMh0NLdXsWLFs47byD3mzx2P51CpF7dRrlw5Zs2aRf/+/cnIyKBGjRp06NCB1157jaCgINPx3NrixYvZuXMnO3fuPOsfSI2w+2f9+vXLNzzuX//6FwBLlizh+uuvN5jM/XTp0oXExET69etHfHw8kZGRxMbGnnXwrJxtzZo13HDDDXkfx8TEQM7wpXHjxhlM5v5GjhwJcNbP49ixY+nevbuhVJ7h8OHDdO3alUOHDhEaGkqzZs1YtGgRN998s+loUsw0pl5ERERExMP59qBbEREREREvoFIvIiIiIuLhVOpFRERERDycSr2IiIiIiIdTqRcRERER8XAq9SIiIiIiHk6lXkRERETEw6nUi4iIiIh4OJV6EREREREPp1IvIiIiIuLhVOpFRERERDycSr2IiIiIiIf7f6l5Uk8iCWKDAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9,6))\n", + "ax.plot(x,y, color='r')\n", + "\n", + "# filling under the curve\n", + "x_fill = np.arange(-4, percentile, 0.01)\n", + "y_fill = stats.norm(0,1).pdf(x_fill)\n", + "ax.fill_between(x_fill, y_fill, 0, color='g')\n", + "plt.title(\"Filled Percentile under Normal Curve\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1f7a26f6-36d8-4561-ad68-db6c19c7720e", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-c469fe12a69725b1", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Machen wir dies alles am Beispiel der Fuchsrote Lockensandbiene fest. Diese ist laut [Bundesministerium für Ernährung und Landwirtschaft](https://www.bmel.de/DE/themen/landwirtschaft/artenvielfalt/bienen-fuettern/wildbienen-honigbienen-und-co.html) 12-14 mm groß. Daher lässt sich annehmen das die meisten Bienen $\\mu=13mm$, mit einer Standardabweichung von $\\sigma=1mm$ haben. Wir wollen nun wissen wie groß 95% der Bienen sind, rechnen wir dies mittels `ppf` aus:" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "6d57bdf0-8e75-4760-8159-d42effd9ea62", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-360e11812d2e9932", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mu = 13 # Mean\n", + "sigma = 1 # std deviation in mm\n", + "\n", + "x_norm = np.linspace(10, 16, 100) # Normaldistribution range from 10-16mm \n", + "y_norm = stats.norm(mu, sigma).pdf(x) # Calculate normal\n", + "\n", + "# Height of 95th percentile of bees\n", + "percentile = stats.norm(mu,sigma).ppf(0.95)\n", + "\n", + "x_percentile = np.arange(x_norm[0], percentile, 0.01)\n", + "y_percentile = stats.norm(mu,sigma).pdf(x_percentile)\n", + "\n", + "# Plot\n", + "fig, ax = plt.subplots(figsize=(9,6))\n", + "ax.plot(x_norm, y_norm, color='r')\n", + "\n", + "# filling under the curve\n", + "ax.fill_between(x_percentile, y_percentile, 0, alpha=0.2, color='#FE0000')\n", + "\n", + "\n", + "# Set text\n", + "ax.text(0.5,0.25,\n", + " f\"95th percentile of bees fall under {percentile:.2f}mm\",\n", + " ha='center', va='center', transform=ax.transAxes,\n", + " bbox={'facecolor':'#fafafa','alpha':1,'edgecolor':'none','pad':1},\n", + " color='#de2e0b'\n", + " )\n", + "\n", + "# Show\n", + "plt.title(\"Filled Percentile under Normal Curve\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e9c59eb8-bfb1-46f2-bf1f-af1ffe59e190", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-7718d285f36c2fad", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "### Aufgabe \n", + "\n", + "*6 Punkte*\n", + "\n", + "Gegeben sind die nach Altersgruppe aufgeschlüsselten Durschnittskörpergrößen (in cm) von Frauen in Deutschland. (Zu finden beim [Statistischen Bundesamt](https://www.destatis.de/DE/Themen/Gesellschaft-Umwelt/Gesundheit/Gesundheitszustand-Relevantes-Verhalten/Tabellen/koerpermasse-frauen.html))\n", + "\n", + "Gehe wie folgt vor:\n", + "\n", + "- Berechne das arithmetische Mittel nutze dafür NumPy. und speichere das Ergebnis mit einer Genauigkeit von 1 Dezimalstelle nach dem Komma in der Variablen `avg_height`.\n", + "- Gegeben ist auch die Standardabweichung von 15cm, stelle die Normalverteilung mittels `norm.pdf` auf. Speichere den Wert in `norm_height` und finde einen geeigneten linespace zum plotten.\n", + "- Berechne folgend die Körpergröße unter die 80% aller Frauen (nach Datenset) fallen. Speichere den Wert in der Variablen `avg_percentile`.\n", + "- Plotte das Ergebnis. Orientiere dich gerne an dem Bienenbeispiel. Finde eine geeignete Darstellung. *Tipp: Da die Y-Achse in diesem Beispiel keinen Sinn ergibt kannst du sie einfach austellen mit `plt.yticks([])`*\n" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "3983d224-e885-43bd-aadd-4e276a56a370", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-048d8330d555432a", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# Given\n", + "avg_height_per_woman = {\n", + " \"18 - 20\": 167.6,\n", + " \"20 - 25\": 167.7,\n", + " \"25 - 30\": 167.3,\n", + " \"30 - 35\": 167.2,\n", + " \"35 - 40\": 167.3,\n", + " \"40 - 45\": 167.5,\n", + " \"45 - 50\": 167.1,\n", + " \"50 - 55\": 167.1,\n", + " \"55 - 60\": 166.9,\n", + " \"60 - 65\": 165.4,\n", + " \"65 - 70\": 164.5,\n", + " \"70 - 75\": 163.9,\n", + " \"75+\": 162.8\n", + "}\n", + "\n", + "avg_height = None\n", + "norm_height = None\n", + "avg_percentile = None" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "2c2e2cf6-c743-4cb0-a329-2240205fc7da", + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-a59f2b3230aad3d6", + "locked": false, + "points": 3, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# BEGIN SOLUTION\n", + "avg_height = np.round(np.mean(list(avg_height_per_woman.values())), decimals=1)\n", + "std_sigma = 15\n", + "\n", + "norm_x = np.linspace(120, 220, 1000)\n", + "norm_height = stats.norm(avg_height, std_sigma).pdf(norm_x)\n", + "\n", + "# Height of 80th percentile of woman heights\n", + "avg_percentile = stats.norm(avg_height, std_sigma).ppf(0.8)\n", + "\n", + "x_percentile = np.arange(norm_x[0], avg_percentile, 0.01)\n", + "y_percentile = stats.norm(avg_height, std_sigma).pdf(x_percentile)\n", + "\n", + "# Plot\n", + "fig, ax = plt.subplots(figsize=(9,6))\n", + "ax.plot(norm_x, norm_height, color='r')\n", + "\n", + "# filling under the curve\n", + "ax.fill_between(x_percentile, y_percentile, 0, alpha=.5, color='#fa0000')\n", + "\n", + "\n", + "# Set text\n", + "ax.text(0.4,0.18,\n", + " f\"80th percentile of Womens heigth\\n fall under {avg_percentile:.1f}cm\",\n", + " ha='center', va='center', transform=ax.transAxes,\n", + " bbox={'facecolor':'#fafafa','alpha':1,'edgecolor':'none','pad':1},\n", + " color='#de2e0b'\n", + " )\n", + "\n", + "# Show\n", + "plt.title(\"Woman Height Normal Distribution\")\n", + "plt.xlabel(\"Height\")\n", + "plt.yticks([]) # hide y\n", + "plt.show()\n", + "# END SOLUTION" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "id": "d9f8aeae-6b51-4645-b578-19693a07ece3", + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-26f141bc8b12d7fe", + "locked": true, + "points": 3, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# Hier werden ihre Lösungen getestet...\n", + "import math \n", + "\n", + "# Check if average height is close to real value\n", + "assert math.isclose(avg_height, 166.3, rel_tol=.2) # 1 Punkt\n", + "\n", + "# Check if norm height is close to real value\n", + "assert math.isclose(np.round(np.sum(norm_height), decimals=1), 10, rel_tol=.2) # 1 Punkt\n", + "\n", + "# Check if percentile is close to real value\n", + "assert math.isclose(avg_percentile, 179, rel_tol=.2) # 1 Punkt" + ] + }, + { + "cell_type": "markdown", + "id": "f50b8883-e018-4a44-831a-1a3c14640955", + "metadata": {}, + "source": [ + "## Probabillity Mass Function - Binomial Verteilung\n", + "\n", + "Im Gegensatz zur Normal Verteilung folgen Binomiale Verteilungen Diskreten Werten. Dies lässt sich am besten am Beispiel zweier unabhängiger Würfel zeigen.\n", + "\n", + "Wir wollen im folgenden also aufzeigen wie die Wahrscheinlichkeits Verteilung zweier 6 seitiger Würfel ist. Da wir die Augenzahl beider Bestimmen führen wir eine Addition aller möglichen Werte vor. Da uns die Auftrittswahrscheinlichkeit interessiert eignet sich ein dict zum speichern der Daten. Dabei ist der Schlüssel die Augenzahl und der Wert die Autrittsanzahl:" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "id": "7a58ad07-9593-4c58-9a86-23a002ef5e94", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{2: 1, 3: 2, 4: 3, 5: 4, 6: 5, 7: 6, 8: 5, 9: 4, 10: 3, 11: 2, 12: 1}\n" + ] + } + ], + "source": [ + "# Two Dices\n", + "first_dice: np.array = np.arange(1,7)\n", + "second_dice: np.array = np.arange(1,7)\n", + "\n", + "# Creating a dict with all keys\n", + "dist: dict = {el: 0 for el in range(2,13)}\n", + "\n", + "# Summing all possible combinations and store them inside the dict\n", + "for el1 in first_dice:\n", + " for el2 in second_dice:\n", + " dice_roll: int = el1 + el2\n", + " dist[dice_roll] += 1\n", + "\n", + "# Print the result\n", + "print(dist)" + ] + }, + { + "cell_type": "markdown", + "id": "0b2ff2d3-e8b0-45e9-9429-8db1acc5e526", + "metadata": {}, + "source": [ + "Wie wir erstmal sehen können folgen die Zahl einem Muster, dieses lässt sich mittels Balkendiagramm visualisieren:" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "id": "f7915dad-d12a-4db1-b691-3fd53ead4027", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(dist.keys(), dist.values(), color='#F00a00')\n", + "plt.xticks(list(dist.keys()))\n", + "plt.title(\"Double Dice role distribution\")\n", + "plt.xlabel(\"Points rolled\")\n", + "plt.ylabel(\"Number of occurrences\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "13e3406d-bb54-482c-a76c-a45a4c309a76", + "metadata": {}, + "source": [ + "Selbiges nur in Prozent statt absolut" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "id": "db27df8d-7bc1-418b-997a-01684eb6fc1e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(nan)" + ] + }, + "execution_count": 214, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vals = np.arange(2,13)\n", + "mean, var = stats.binom.stats(13, 0.5)\n", + "dist = stats.binom.pmf(7, mean, var)\n", + "dist" + ] + }, + { + "cell_type": "code", + "execution_count": 198, + "id": "41b90981-ef18-40b4-bb03-9cd3407869b4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(np.arange(2,12),stats.binom.pmf(np.arange(2,12), 12, 0.5))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "id": "1d3d7273-ed46-42e4-8ce6-cded64f81e5c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 209, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAfZElEQVR4nO3dfWyV9f3/8VdvaItI64TR0lJajUjBQqu9s9Wv3WZjIZ1at2FtnG064mICCJ6NSRugM94cXKwpSkNXEzVuI2VsgyFiFTvKZigWWohWnXdT24Cnhbi1UGchPef3x1ePv/PlcHMqcN6nPB/JiXL1c128r0sjT69zejXM4/F4BAAAYFh4sAcAAAA4E4IFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5kUGe4Bzwe1269ChQ5o4caLCwsKCPQ4AADgLHo9HR48eVWJiosLDT38PZUwEy6FDh5ScnBzsMQAAwCj09vZq2rRpp10zJoJl4sSJ0lcnHBsbG+xxAADAWRgcHFRycrL3z/HTGRPB8vXbQLGxsQQLAAAh5mw+zsGHbgEAgHkECwAAMG9UwdLQ0KDU1FTFxMQoLy9PHR0dp1z79ttv68c//rFSU1MVFham+vr6b31MAABwcQk4WDZu3CiHw6Ha2lp1dXUpIyNDxcXF6u/v97v+iy++0JVXXqk1a9YoISHhnBwTAABcXMI8Ho8nkB3y8vKUk5OjdevWSV89AyU5OVlLlizRihUrTrtvamqqli1bpmXLlp2zY+qrTxnHxcVpYGCAD90CABAiAvnzO6A7LMePH1dnZ6eKioq+OUB4uIqKitTe3j6qYUdzzOHhYQ0ODvq8AADA2BVQsBw5ckQjIyOKj4/32R4fHy+XyzWqAUZzTKfTqbi4OO+Lh8YBADC2heR3CVVXV2tgYMD76u3tDfZIAADgPArowXGTJ09WRESE+vr6fLb39fWd8gO15+OY0dHRio6OHtXvBwAAQk9Ad1iioqKUlZWl1tZW7za3263W1lbl5+ePaoDzcUwAADC2BPxofofDocrKSmVnZys3N1f19fUaGhpSVVWVJKmiokJJSUlyOp3SVx+qfeedd7x/f/DgQR04cECXXnqprrrqqrM6JgAAuLgFHCxlZWU6fPiwVq9eLZfLpczMTLW0tHg/NNvT0+PzI6IPHTqka6+91vvrJ554Qk888YQKCwvV1tZ2VscEAAAXt4Cfw2IRz2EBACD0nLfnsAAAAARDwG8JATi/Ule8FOwRguKTNSXBHgGAYdxhAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYN6pgaWhoUGpqqmJiYpSXl6eOjo7Trt+0aZPS0tIUExOjOXPmaPv27T5fP3bsmBYvXqxp06Zp/Pjxmj17thobG0czGgAAGIMCDpaNGzfK4XCotrZWXV1dysjIUHFxsfr7+/2u3717t8rLy7Vw4ULt379fpaWlKi0tVXd3t3eNw+FQS0uLfv/73+vdd9/VsmXLtHjxYm3duvXbnR0AABgTwjwejyeQHfLy8pSTk6N169ZJktxut5KTk7VkyRKtWLHipPVlZWUaGhrStm3bvNuuv/56ZWZmeu+ipKenq6ysTKtWrfKuycrK0vz58/XII4+ccabBwUHFxcVpYGBAsbGxgZwOYE7qipeCPUJQfLKmJNgjALjAAvnzO6A7LMePH1dnZ6eKioq+OUB4uIqKitTe3u53n/b2dp/1klRcXOyzvqCgQFu3btXBgwfl8Xi0c+dOvf/++7rlllv8HnN4eFiDg4M+LwAAMHYFFCxHjhzRyMiI4uPjfbbHx8fL5XL53cflcp1x/dNPP63Zs2dr2rRpioqK0rx589TQ0KCbbrrJ7zGdTqfi4uK8r+Tk5EBOAwAAhBgT3yX09NNPa8+ePdq6das6OztVV1enRYsW6bXXXvO7vrq6WgMDA95Xb2/vBZ8ZAABcOJGBLJ48ebIiIiLU19fns72vr08JCQl+90lISDjt+v/+97+qqanR5s2bVVLyv+9hz507VwcOHNATTzxx0ttJkhQdHa3o6OhARgcAACEsoDssUVFRysrKUmtrq3eb2+1Wa2ur8vPz/e6Tn5/vs16SduzY4V1/4sQJnThxQuHhvqNERETI7XYHMh4AABijArrDoq++BbmyslLZ2dnKzc1VfX29hoaGVFVVJUmqqKhQUlKSnE6nJGnp0qUqLCxUXV2dSkpK1NzcrH379qmpqUmSFBsbq8LCQi1fvlzjx49XSkqKdu3apRdeeEFPPvnkuT5fAAAQggIOlrKyMh0+fFirV6+Wy+VSZmamWlpavB+s7enp8blbUlBQoA0bNmjlypWqqanRjBkztGXLFqWnp3vXNDc3q7q6Wnfffbc+//xzpaSk6NFHH9V99913rs4TAACEsICfw2IRz2HBWMJzWABcLM7bc1gAAACCgWABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPNGFSwNDQ1KTU1VTEyM8vLy1NHRcdr1mzZtUlpammJiYjRnzhxt3779pDXvvvuubrvtNsXFxWnChAnKyclRT0/PaMYDAABjTMDBsnHjRjkcDtXW1qqrq0sZGRkqLi5Wf3+/3/W7d+9WeXm5Fi5cqP3796u0tFSlpaXq7u72rvnoo4904403Ki0tTW1tbXrzzTe1atUqxcTEfLuzAwAAY0KYx+PxBLJDXl6ecnJytG7dOkmS2+1WcnKylixZohUrVpy0vqysTENDQ9q2bZt32/XXX6/MzEw1NjZKku666y6NGzdOv/vd70Z1EoODg4qLi9PAwIBiY2NHdQzAitQVLwV7hKD4ZE1JsEcAcIEF8ud3QHdYjh8/rs7OThUVFX1zgPBwFRUVqb293e8+7e3tPuslqbi42Lve7XbrpZde0tVXX63i4mJNmTJFeXl52rJlyynnGB4e1uDgoM8LAACMXQEFy5EjRzQyMqL4+Hif7fHx8XK5XH73cblcp13f39+vY8eOac2aNZo3b55effVV3XHHHfrRj36kXbt2+T2m0+lUXFyc95WcnBzIaQAAgBAT9O8ScrvdkqTbb79dDzzwgDIzM7VixQr98Ic/9L5l9H9VV1drYGDA++rt7b3AUwMAgAspMpDFkydPVkREhPr6+ny29/X1KSEhwe8+CQkJp10/efJkRUZGavbs2T5rZs2apddff93vMaOjoxUdHR3I6AAAIIQFdIclKipKWVlZam1t9W5zu91qbW1Vfn6+333y8/N91kvSjh07vOujoqKUk5Oj9957z2fN+++/r5SUlEDGAwAAY1RAd1gkyeFwqLKyUtnZ2crNzVV9fb2GhoZUVVUlSaqoqFBSUpKcTqckaenSpSosLFRdXZ1KSkrU3Nysffv2qampyXvM5cuXq6ysTDfddJO+//3vq6WlRS+++KLa2trO5bkCAIAQFXCwlJWV6fDhw1q9erVcLpcyMzPV0tLi/WBtT0+PwsO/uXFTUFCgDRs2aOXKlaqpqdGMGTO0ZcsWpaene9fccccdamxslNPp1P3336+ZM2fqz3/+s2688cZzdZ4AACCEBfwcFot4DgvGEp7DAuBicd6ewwIAABAMBAsAADCPYAEAAOYRLAAAwDyCBQAAmEewAAAA8wgWAABgHsECAADMI1gAAIB5BAsAADCPYAEAAOYF/MMPgbPFz8TBhcK/a8DYxx0WAABgHsECAADMI1gAAIB5BAsAADCPYAEAAOYRLAAAwDyCBQAAmEewAAAA8wgWAABgHsECAADMI1gAAIB5BAsAADCPYAEAAOYRLAAAwDyCBQAAmEewAAAA8wgWAABgHsECAADMI1gAAIB5BAsAADCPYAEAAOYRLAAAwDyCBQAAmEewAAAA8wgWAABgHsECAADMI1gAAIB5BAsAADCPYAEAAOYRLAAAwDyCBQAAmEewAAAA8wgWAABgHsECAADMI1gAAIB5BAsAADCPYAEAAOYRLAAAwDyCBQAAmEewAAAA8wgWAABgHsECAADMI1gAAIB5BAsAADCPYAEAAOYRLAAAwDyCBQAAmEewAAAA8wgWAABg3qiCpaGhQampqYqJiVFeXp46OjpOu37Tpk1KS0tTTEyM5syZo+3bt59y7X333aewsDDV19ePZjQAADAGBRwsGzdulMPhUG1trbq6upSRkaHi4mL19/f7Xb97926Vl5dr4cKF2r9/v0pLS1VaWqru7u6T1m7evFl79uxRYmLi6M4GAACMSQEHy5NPPql7771XVVVVmj17thobG3XJJZfo2Wef9bt+7dq1mjdvnpYvX65Zs2bp4Ycf1nXXXad169b5rDt48KCWLFmiP/zhDxo3btzozwgAAIw5AQXL8ePH1dnZqaKiom8OEB6uoqIitbe3+92nvb3dZ70kFRcX+6x3u9265557tHz5cl1zzTVnnGN4eFiDg4M+LwAAMHYFFCxHjhzRyMiI4uPjfbbHx8fL5XL53cflcp1x/eOPP67IyEjdf//9ZzWH0+lUXFyc95WcnBzIaQAAgBAT9O8S6uzs1Nq1a/X8888rLCzsrPaprq7WwMCA99Xb23ve5wQAAMETULBMnjxZERER6uvr89ne19enhIQEv/skJCScdv0//vEP9ff3a/r06YqMjFRkZKQ+/fRT/eIXv1BqaqrfY0ZHRys2NtbnBQAAxq6AgiUqKkpZWVlqbW31bnO73WptbVV+fr7fffLz833WS9KOHTu86++55x69+eabOnDggPeVmJio5cuX65VXXhndWQEAgDElMtAdHA6HKisrlZ2drdzcXNXX12toaEhVVVWSpIqKCiUlJcnpdEqSli5dqsLCQtXV1amkpETNzc3at2+fmpqaJEmTJk3SpEmTfH6PcePGKSEhQTNnzjw3ZwkAAEJawMFSVlamw4cPa/Xq1XK5XMrMzFRLS4v3g7U9PT0KD//mxk1BQYE2bNiglStXqqamRjNmzNCWLVuUnp5+bs8EAACMWQEHiyQtXrxYixcv9vu1tra2k7YtWLBACxYsOOvjf/LJJ6MZCwAAjFFB/y4hAACAMyFYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMC8UQVLQ0ODUlNTFRMTo7y8PHV0dJx2/aZNm5SWlqaYmBjNmTNH27dv937txIkTevDBBzVnzhxNmDBBiYmJqqio0KFDh0YzGgAAGIMCDpaNGzfK4XCotrZWXV1dysjIUHFxsfr7+/2u3717t8rLy7Vw4ULt379fpaWlKi0tVXd3tyTpiy++UFdXl1atWqWuri795S9/0Xvvvafbbrvt258dAAAYE8I8Ho8nkB3y8vKUk5OjdevWSZLcbreSk5O1ZMkSrVix4qT1ZWVlGhoa0rZt27zbrr/+emVmZqqxsdHv77F3717l5ubq008/1fTp08840+DgoOLi4jQwMKDY2NhATgfnUeqKl4I9QlB8sqbkW+3PdQsc1wwITYH8+R3QHZbjx4+rs7NTRUVF3xwgPFxFRUVqb2/3u097e7vPekkqLi4+5XpJGhgYUFhYmC677DK/Xx8eHtbg4KDPCwAAjF0BBcuRI0c0MjKi+Ph4n+3x8fFyuVx+93G5XAGt//LLL/Xggw+qvLz8lLXldDoVFxfnfSUnJwdyGgAAIMSY+i6hEydO6M4775TH49H69etPua66uloDAwPeV29v7wWdEwAAXFiRgSyePHmyIiIi1NfX57O9r69PCQkJfvdJSEg4q/Vfx8qnn36qv/3tb6d9Lys6OlrR0dGBjA4AAEJYQHdYoqKilJWVpdbWVu82t9ut1tZW5efn+90nPz/fZ70k7dixw2f917HywQcf6LXXXtOkSZMCPxMAADBmBXSHRZIcDocqKyuVnZ2t3Nxc1dfXa2hoSFVVVZKkiooKJSUlyel0SpKWLl2qwsJC1dXVqaSkRM3Nzdq3b5+ampqkr2LlJz/5ibq6urRt2zaNjIx4P99y+eWXKyoq6tyeMQAACDkBB0tZWZkOHz6s1atXy+VyKTMzUy0tLd4P1vb09Cg8/JsbNwUFBdqwYYNWrlypmpoazZgxQ1u2bFF6erok6eDBg9q6daskKTMz0+f32rlzp773ve9923MEAAAhLuBgkaTFixdr8eLFfr/W1tZ20rYFCxZowYIFftenpqYqwEfBAACAi4yp7xICAADwh2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmESwAAMA8ggUAAJhHsAAAAPMIFgAAYB7BAgAAzCNYAACAeQQLAAAwj2ABAADmRQZ7gFCQuuKlYI8QFJ+sKQn2CADOI/7bhlDCHRYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwjWAAAgHkECwAAMI9gAQAA5hEsAADAPIIFAACYR7AAAADzCBYAAGAewQIAAMwbVbA0NDQoNTVVMTExysvLU0dHx2nXb9q0SWlpaYqJidGcOXO0fft2n697PB6tXr1aU6dO1fjx41VUVKQPPvhgNKMBAIAxKOBg2bhxoxwOh2pra9XV1aWMjAwVFxerv7/f7/rdu3ervLxcCxcu1P79+1VaWqrS0lJ1d3d71/zmN7/RU089pcbGRr3xxhuaMGGCiouL9eWXX367swMAAGNCwMHy5JNP6t5771VVVZVmz56txsZGXXLJJXr22Wf9rl+7dq3mzZun5cuXa9asWXr44Yd13XXXad26ddJXd1fq6+u1cuVK3X777Zo7d65eeOEFHTp0SFu2bPn2ZwgAAEJeZCCLjx8/rs7OTlVXV3u3hYeHq6ioSO3t7X73aW9vl8Ph8NlWXFzsjZGPP/5YLpdLRUVF3q/HxcUpLy9P7e3tuuuuu0465vDwsIaHh72/HhgYkCQNDg4GcjpnzT38xXk5rnXf9npy3UaH6xY4rtnocN1GJ732lXM2Syjpfqj4nB/z638WHo/njGsDCpYjR45oZGRE8fHxPtvj4+P1z3/+0+8+LpfL73qXy+X9+tfbTrXm/3I6nXrooYdO2p6cnBzI6eAM4uqDPUFo4rqNDtctcFyz0eG6jc75vG5Hjx5VXFzcadcEFCxWVFdX+9y1cbvd+vzzzzVp0iSFhYUFdbZzaXBwUMnJyert7VVsbGywxwkZXLfR4boFjms2Oly30RmL183j8ejo0aNKTEw849qAgmXy5MmKiIhQX1+fz/a+vj4lJCT43SchIeG067/+a19fn6ZOneqzJjMz0+8xo6OjFR0d7bPtsssuC+RUQkpsbOyY+ZfzQuK6jQ7XLXBcs9Hhuo3OWLtuZ7qz8rWAPnQbFRWlrKwstba2ere53W61trYqPz/f7z75+fk+6yVpx44d3vVXXHGFEhISfNYMDg7qjTfeOOUxAQDAxSXgt4QcDocqKyuVnZ2t3Nxc1dfXa2hoSFVVVZKkiooKJSUlyel0SpKWLl2qwsJC1dXVqaSkRM3Nzdq3b5+ampokSWFhYVq2bJkeeeQRzZgxQ1dccYVWrVqlxMRElZaWnuvzBQAAISjgYCkrK9Phw4e1evVquVwuZWZmqqWlxfuh2Z6eHoWHf3PjpqCgQBs2bNDKlStVU1OjGTNmaMuWLUpPT/eu+dWvfqWhoSH9/Oc/13/+8x/deOONamlpUUxMzLk6z5AUHR2t2trak97+wulx3UaH6xY4rtnocN1G52K/bmGes/leIgAAgCDiZwkBAADzCBYAAGAewQIAAMwjWAAAgHkEi0F///vfdeuttyoxMVFhYWH8EMiz4HQ6lZOTo4kTJ2rKlCkqLS3Ve++9F+yxzFu/fr3mzp3rfRBVfn6+Xn755WCPFXLWrFnjfUQDTu3Xv/61wsLCfF5paWnBHsu8gwcP6qc//akmTZqk8ePHa86cOdq3b1+wx7rgCBaDhoaGlJGRoYaGhmCPEjJ27dqlRYsWac+ePdqxY4dOnDihW265RUNDQ8EezbRp06ZpzZo16uzs1L59+/SDH/xAt99+u95+++1gjxYy9u7dq9/+9reaO3dusEcJCddcc40+++wz7+v1118P9kim/fvf/9YNN9ygcePG6eWXX9Y777yjuro6fec73wn2aBdcSP4sobFu/vz5mj9/frDHCCktLS0+v37++ec1ZcoUdXZ26qabbgraXNbdeuutPr9+9NFHtX79eu3Zs0fXXHNN0OYKFceOHdPdd9+tZ555Ro888kiwxwkJkZGRp/xRLjjZ448/ruTkZD333HPebVdccUVQZwoW7rBgTBoYGJAkXX755cEeJWSMjIyoublZQ0ND/FiMs7Ro0SKVlJSoqKgo2KOEjA8++ECJiYm68sordffdd6unpyfYI5m2detWZWdna8GCBZoyZYquvfZaPfPMM8EeKyi4w4Ixx+12a9myZbrhhht8nqgM/9566y3l5+fryy+/1KWXXqrNmzdr9uzZwR7LvObmZnV1dWnv3r3BHiVk5OXl6fnnn9fMmTP12Wef6aGHHtL//M//qLu7WxMnTgz2eCb961//0vr16+VwOFRTU6O9e/fq/vvvV1RUlCorK4M93gVFsGDMWbRokbq7u3lv/CzNnDlTBw4c0MDAgP70pz+psrJSu3btIlpOo7e3V0uXLtWOHTsu+h8hEoj//63uuXPnKi8vTykpKfrjH/+ohQsXBnU2q9xut7Kzs/XYY49Jkq699lp1d3ersbHxogsW3hLCmLJ48WJt27ZNO3fu1LRp04I9TkiIiorSVVddpaysLDmdTmVkZGjt2rXBHsu0zs5O9ff367rrrlNkZKQiIyO1a9cuPfXUU4qMjNTIyEiwRwwJl112ma6++mp9+OGHwR7FrKlTp570Pw+zZs26KN9K4w4LxgSPx6MlS5Zo8+bNamtru2g/lHYuuN1uDQ8PB3sM026++Wa99dZbPtuqqqqUlpamBx98UBEREUGbLZQcO3ZMH330ke65555gj2LWDTfccNIjGt5//32lpKQEbaZgIVgMOnbsmM//cXz88cc6cOCALr/8ck2fPj2os1m1aNEibdiwQX/96181ceJEuVwuSVJcXJzGjx8f7PHMqq6u1vz58zV9+nQdPXpUGzZsUFtbm1555ZVgj2baxIkTT/p81IQJEzRp0iQ+N3Uav/zlL3XrrbcqJSVFhw4dUm1trSIiIlReXh7s0cx64IEHVFBQoMcee0x33nmnOjo61NTUpKampmCPduF5YM7OnTs9kk56VVZWBns0s/xdL0me5557Ltijmfazn/3Mk5KS4omKivJ897vf9dx8882eV199NdhjhaTCwkLP0qVLgz2GaWVlZZ6pU6d6oqKiPElJSZ6ysjLPhx9+GOyxzHvxxRc96enpnujoaE9aWpqnqakp2CMFRZjnf/9jDwAAYBYfugUAAOYRLAAAwDyCBQAAmEewAAAA8wgWAABgHsECAADMI1gAAIB5BAsAADCPYAEAAOYRLAAAwDyCBQAAmEewAAAA8/4f5L3rwHG1O8cAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(np.arange(1,7),stats.binom.pmf(np.arange(1,7), 6, 0.5) * stats.binom.pmf(np.arange(1,7), 6, 0.5))" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "id": "2285d290-73a2-4c2d-8542-46c6aea2c71b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.00878906, 0.05493164, 0.09765625, 0.05493164, 0.00878906])" + ] + }, + "execution_count": 203, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stats.binom.pmf(np.arange(1,6), 6, 0.5) * stats.binom.pmf(np.arange(1,6), 6, 0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b142059-c19b-49c4-bc4b-02ca875b1fbf", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/To Do.md b/To Do.md index d5905f3..1f50389 100644 --- a/To Do.md +++ b/To Do.md @@ -1,8 +1,4 @@ - [ ] Obsidian publish over https://github.com/oleeskild/Obsidian-digital-garden -5ce6c08f9b055ca085232da514623ca4 - Aurela Brahimi -8be9a4cc0b240a18171892b873dc2cb8 - Milena Krieger 30 - - \ No newline at end of file