From e98d12b3c805afe07666337165fd79cc6377c7a0 Mon Sep 17 00:00:00 2001
From: bpkleer <benk@sowi.jlug.de>
Date: Tue, 28 Sep 2021 17:25:03 +0200
Subject: [PATCH] adapted design

---
 slides/ggplot-advanced.Rmd    | 27 ++++++++-----
 slides/gt-grammar.Rmd         | 41 +++++++++++--------
 slides/if-loops-functions.Rmd | 75 +++++++++++++++--------------------
 slides/stringr-grammar.Rmd    | 12 +++---
 4 files changed, 79 insertions(+), 76 deletions(-)

diff --git a/slides/ggplot-advanced.Rmd b/slides/ggplot-advanced.Rmd
index a5bb84c..e8dcc2c 100644
--- a/slides/ggplot-advanced.Rmd
+++ b/slides/ggplot-advanced.Rmd
@@ -1,14 +1,18 @@
 ---
+title: "Weiterführende Darstellungen in `ggplot2`"
+
 output: 
   html_document:
       toc: true
       toc_float:
         toc_collapsed: true
         smooth_scroll: true
+      toc_depth: 3
       widescreen: true
-      highlight: pygments
-      theme: readable
-      css: ./styles/style.css
+      highlightStyle: github
+      highlightLines: true
+      highlightLanguage: ["r"]
+      css: styles/htmlbook.css
       df_print: paged
       mathjax: default
       self_contained: false
@@ -39,10 +43,7 @@ opts_chunk$set(#fig.path = 'pics/s6-', # path for calculated figures
                eval = FALSE,    # Code is NOT evaluated
                warning = FALSE, # warnings are NOT displayed
                message = FALSE, # messages are NOT displayed
-               size = "tiny",  # latex-size of code chunks
-               background = "#E7E7E7", # background color of code chunks
                comment = "", # no hashtags before output
-               options(width = 80),
                results = "markdown",
                rows.print = 15
 )
@@ -57,7 +58,8 @@ htmltools::tagList(
 )
 ```
 
-## Weiterführende Darstellungen in ```ggplot2```
+# Start
+
 In diesem Teil des Kurses werden weiterführende Einstellungen innerhalb des Pakets ```ggplot2``` dargestellt. Aufbauend auf die Einführung in die Grammatik von ```ggplot``` werden folgende Teile dargestellt:
 
 - Schriftarten bearbeiten bzw. Darstellung des Plots
@@ -72,7 +74,8 @@ In diesem Teil des Kurses werden weiterführende Einstellungen innerhalb des Pak
 
 Eine gute Ãœbersicht bietet auch folgendes [Online-Lernbuch](https://r-graphics.org) (auf Englisch). 
 
-## Weitere Layout-Fragen
+# Weitere Layout-Fragen
+
 Innerhalb eines ```ggplots``` können nahezu alle dargestellten Teilbereiche verändert und angepasst werden. Einige dieser Änderungen werden wie im nachfolgenden besprechen.
 
 Dazu schaffen wir uns zuerst nochmal ein ggplot-Objekt mit unserem Scatterplot aus der Einführung in ```ggplot```:
@@ -240,7 +243,8 @@ scatterGrid +
  
 Es gibt ebenso eine ganze Reihe an vorgefertigten Themes, die dann wiederum individuell angepasst werden können. Eine Übersicht über vorhandene Themes gibt es [hier](https://ggplot2.tidyverse.org/reference/ggtheme.html).
 
-## Annotations
+# Annotations
+
 Neben den ganzen Spielereien möchte man manchmal auch einzelne Bereiche einer Grafik besonders hervorheben oder aber zum Beispiel Beschriftungen der Fälle hinzufügen (bei kleinem n). 
 
 Hierzu gibt es die Funktionen ```geom_text()``` und ```annotate()```, die mit ```ggplot``` genutzt werden können. Dazu nehmen wir wieder das Scatterplot vom Beginn, begrenzen aber diesmal die Anzahl auf 15, damit wir eine klare Darstellung bekommen. **Wichtig**: ```geom_jitter()``` kann nicht genutzt werden, da die Datenbeschriftungen am Datenpunkt und nicht am gejitterten Datenpunkt auftauchen!
@@ -382,7 +386,8 @@ scatter +
            )
 ```
 
-## Grafikpakete zur Darstellung von *missing values*
+# Grafikpakete zur Darstellung von *missing values*
+
 Oftmals möchte man bevor man die eigentliche Datenanalyse beginnt, zuerst die Daten inspizieren und vor allem die **missing values** prüfen. Dazu gibt es zwei umfangreiche Pakete, die auf ```ggplot2``` aufbauen. Dies sind: ```naniar``` und ```UpSetR```.
 
 Zuerst installieren bzw. laden wir die Pakete:
@@ -611,7 +616,7 @@ gg_miss_fct(x = uniMis,
   labs(title = "NA in Uni-df nach Studienfach")
 ```
 
-## Darstellungen von Regressionsmodellen
+# Darstellungen von Regressionsmodellen
 Oftmals ist es nicht nur das Ziel Regressionsmodelle in Tabellen darzustellen, sondern auch spezifische Effekte grafisch darzustellen. Dazu stellen wir hier eine Möglichkeit vor: manuell über eigene **predictions**. 
 
 Es gibt zwar *packages* wie ```ggiraphExtra```, diese können aber nur sehr eingeschränkt plotten. 
diff --git a/slides/gt-grammar.Rmd b/slides/gt-grammar.Rmd
index 6eaf160..ef2bbba 100644
--- a/slides/gt-grammar.Rmd
+++ b/slides/gt-grammar.Rmd
@@ -1,14 +1,18 @@
 ---
+title: "Tabellen publizierbar erstellen mit `gt`"
+
 output: 
   html_document:
       toc: true
       toc_float:
         toc_collapsed: true
         smooth_scroll: true
+      toc_depth: 3
       widescreen: true
-      highlight: pygments
-      theme: readable
-      css: ./styles/style.css
+      highlightStyle: github
+      highlightLines: true
+      highlightLanguage: ["r"]
+      css: styles/htmlbook.css
       df_print: paged
       mathjax: default
       self_contained: false
@@ -71,7 +75,8 @@ htmltools::tagList(
 ```
 
 
-## Tabellen publizierbar erstellen mit ```gt```
+# Start
+
 Das *package* ```gt``` (*grammar of tables*) inkludiert hilfreiche Funktionen, um Tabellen aus R in ein Format zu exportieren, das in wissenschaftlichen Arbeiten oder bei Präsentationen genutzt werden kann. 
 
 Das Paket ist umfassend und hier werden nur einführende Schritte dargestellt, die aber für erste Projekte im BA-Studium hilfreich sind. Die genaue Dokumentation findet sich in der [Benutzerdokumentation](https://gt.rstudio.com/).
@@ -100,7 +105,8 @@ library("gt")
 library("tidyverse")
 ```
 
-## Eine einfache Tabelle
+# Eine einfache Tabelle
+
 Bevor wir nun Kreuztabellen darstellen, machen wir eine einfache Tabelle. Wir wollen zum Beispiel die Häufigkeiten für die *Studienmotivation* ausgeben lassen (```mot```).
 
 ```{r r-table, eval=TRUE}
@@ -132,7 +138,8 @@ uni %>%
 
 Fertig ist die Darstellung der absoluten Häufigkeiten der Variable ```mot```. Dies sieht schon viel schöner aus als in der R Konsole (und ist auch als Bild exportierbar, dazu später mehr). Bevor nun einzelne Formatierungsmöglichkeiten in ```gt``` gezeigt werden, gehen wir über zu Kreuztabellen und zur Ausgabe prozentualer Häufigkeiten.
 
-## Kreuztabelle
+# Kreuztabelle
+
 Wir nehmen wieder ein Beispiel aus dem Trainingsdatensatz ```uni```. Wir möchten eine Kreuztabelle zwischen Studienort (```city```) und Studienfach (```study```) erstellen. Wir möchten wissen, wie viele Personen jeweils in den einzelnen Städten die spezifischen Fächer studieren. 
 
 ``` {r example-crosstable, eval=TRUE}
@@ -160,6 +167,7 @@ uni %>%
 Wir sehen, dass wir nun ein *tibble* haben, der in der ersten Spalte die Ausprägungen von ```study``` hat, und die zweite bis vierte Spalte stellen die Ausprägungen von ```city``` dar. In den einzelnen Feldern befindet sich die Summe der einzelnen Paare. 
 
 ## Kreuztabelle mit ```gt```
+
 Als nächstes werden wir jetzt dann die Funktion ```gt()``` aufrufen:
 
 ```{r gt-crosstable1, eval=TRUE}
@@ -220,7 +228,8 @@ uni %>%
 
 Nun haben wir also eine Kreuztabelle mit absoluten Häufigkeiten und eine mit relativen Häufigkeiten. In den nächsten Schritten wird die Tabelle formatiert. 
 
-## Formatierungen in ```gt```
+# Formatierungen in ```gt```
+
 Um die Tabellen nun zu formatieren, speichern wir diese zuerst in einem Objekt: Denn R ist objektorientiert! Wir nehmen die absolute Häufigkeitstabelle der Variable ```mot``` und die prozentuale Kreuztabelle ziwschen ```city``` und ```study```. **Wichtig hierbei**: Erinnere dich an die Abbildung zu Beginn, in der alle einzelnen Bereiche einer ```gt```-Tabelle benannt waren!
 ```{r gt-objects, eval=TRUE}
 single <- uni %>% 
@@ -253,6 +262,7 @@ cross <- uni %>%
 ```
 
 ## Titel ändern
+
 Zuerst fügen wir der Häufigkeitstabelle nun einen Titel hinzu, damit klar ist, um was für Daten es sich handelt.
 ```{r gt-single1, eval= TRUE}
 single %>% 
@@ -260,6 +270,7 @@ single %>%
 ```
 
 ## Alignment ändern
+
 Wie wir sehen, sind die Spalten rechts ausgerichtet, dies können wir ebenfalls ändern und zentrieren es nun:
 ```{r gt-single2, eval = TRUE}
 single %>% 
@@ -268,6 +279,7 @@ single %>%
 ```
 
 ## Quelle \& Fußnote hinzufügen
+
 Oft werden unter Tabellen Quellen oder Anmerkungen angegeben, dies können wir auch ganz einfach mit ```gt```machen:
 ```{r gt-single3, eval=TRUE}
 single %>%
@@ -296,6 +308,7 @@ single %>%
 ```
 
 ## Spaltenbreite ändern
+
 Als kleineres Manko sehen wir jetzt noch, dass die Spalten unterschiedlich breit sind. Dies können wir über ```cols_width()``` ändern. Hierbei können wir einzelnen Spalten aufrufen oder einen Bereich an Spalten festlegen. Wir könnten z.B. die Breite von Spalte 4 erhöhen. Hierzu nutzen wir die Hilfsfunktion ```px()```, die die Größe in Pixel angibt. 
 ```{r gt-single-colwidth, eval=TRUE}
 single %>%
@@ -333,6 +346,7 @@ single %>%
 ```
 
 ## Schriftart \& Schriftgröße ändern
+
 Innerhalb von ```tab_options()``` gibt es eine Vielzahl von Optionen. Um Schriftarten zu ändern, muss man zuvor das *package* ```extrafont``` laden. 
 
 ```{r extrafont, eval=FALSE}
@@ -377,7 +391,8 @@ single %>%
 
 Dies stellt nur einen Ausschnitt der Funktionsmöglichkeiten von ```gt``` dar. Es können auch einzelne Zellen spezifisch farbig gestaltet werden und auch nach einer weiteren Variable dargestellt werden. Dazu ist ein Blick in die [Benutzerdokumentation](https://gt.rstudio.com/) hilfreich.
 
-## Anpassungen bei Kreuztabellen
+### Anpassungen bei Kreuztabellen
+
 Nun wollen wir abschließend noch die Kreuztablle anpassen. Wir übernehmen die oben eingeführten Anpassungen für den Title, die Spaltenbreite und die Quelle. Die erste Spalte machen wir nun aber breiter als die anderen. Auch richten wir die erste Spalte links aus (wie nach Konvention üblich).
 
 ```{r gt-crosstable-adaptions, eval=TRUE}
@@ -496,12 +511,4 @@ cross %>%
 ```
 
 ### Das war's!
-Die Labs findet ihr in der RStudio Cloud unter ```task gt```.
-
-Ihr sehr hier drei verschiedene Tabellendarstellungen. Sucht euch eine Tabellendarstellung heraus und stellt diese mithilfe des ```gt```-*package* nach. 
-
-![gt Task 1](./pics/gt-task1.png)
-
-![gt Task 2](./pics/gt-task2.png)
-
-![gt Task 3](./pics/gt-task3.png)
+Die Labs findet ihr in der RStudio Cloud unter ```task gt```.
\ No newline at end of file
diff --git a/slides/if-loops-functions.Rmd b/slides/if-loops-functions.Rmd
index 432cbbd..9ece17e 100644
--- a/slides/if-loops-functions.Rmd
+++ b/slides/if-loops-functions.Rmd
@@ -1,14 +1,18 @@
 ---
+title: "Bedingungen, Schleifen & eigene Funktionen"
+
 output: 
   html_document:
       toc: true
       toc_float:
         toc_collapsed: true
         smooth_scroll: true
+      toc_depth: 3
       widescreen: true
-      highlight: pygments
-      theme: readable
-      css: ./styles/style.css
+      highlightStyle: github
+      highlightLines: true
+      highlightLanguage: ["r"]
+      css: styles/htmlbook.css
       df_print: paged
       mathjax: default
       self_contained: false
@@ -56,11 +60,11 @@ htmltools::tagList(
 )
 ```
 
-## Bedingungen, Schleifen & eigene Funktionen
+# Start
 In diesem Teil des Workshops werden zuerst **if**-Ausdrücke wiederholt (bzw. eingeführt) und anschließend die Nutzung von **Schleifen** vorgestellt. Schleifen haben den Vorteil, dass man einen Codierungsschritt auf eine bestimmte Anzahl bzw. Fälle (in Kombination mit **if**) wiederholen kann. Somit erspart man sich Code-Schreibarbeit. Als letztes werden **Funktionen** eingeführt. 
 
 
-## If-Bedingung
+# If-Bedingung
 Der **if**-Ausdruck wird dann genutzt, wenn man einen Befehl unter bestimmten Bedingungen ausführen möchte. Dabei wird eine Bedingung (*condition*) überprüft und sofern diese zutrifft (```TRUE```), wird die angegebene Operation durchgeführt. 
 
 Die Logik des einfachen **if**-Ausdrucks ist im Schaubild dargestellt:
@@ -87,9 +91,7 @@ Der einfache **if**-Ausdruck folgt also einem ganz klaren Muster:
 
 Der einfache **if**-Ausdruck kann also ganz leicht umgesetzt werden. 
 
-<br>
-
-### else if Ausdruck
+## else if Ausdruck
 
 Neben dem einfachen **if**-Ausdruck gibt es auch noch die **else if**-Ausdrücke, mit denen man weitere Bedingungen prüfen kann, falls die vorherige Bedingung nicht zutrifft. Hier durchläuft der Prüfprozess also mehrere Bedingungen. Dies ist im Schaubild dargestellt:
 
@@ -131,7 +133,8 @@ if (mot >= 7) {
 
 Das einzige, was wir hier verändert haben, ist dass wir eine dritte Prüfbedingung hinzugefügt haben. Wie zuvor wird diese dritte Bedingung erst geprüft, wenn die erste und die zweite Bedingung beide ```FALSE``` sind. **else if**-Ausdrücke haben also eine **hierarchische** Struktur.
 
-### else Ausdruck
+## else Ausdruck
+
 Man kann auch dichotome Entscheidungen treffen. Nehmen wir an, wir möchten nur nach *motiviert* und *nicht motiviert* unterscheiden und entscheiden uns, Personen, die einen Wert über $7$ angegeben haben, als motiviert zu bewerten und Personen mit niedrigeren Skalenwerten als nicht motiviert. Wir prüfen hier nur die Bedingung, ob der Wert größer $7$ ist. Falls dies nicht zutrifft, entscheiden wir mit **else** (in allen anderen Fällen), dass *nicht motiviert* ausgegeben wird.**Else** beinhaltet also eine Anweisung, die ausgeführt wird für alle Fälle, auf denen die zuvor genannte **if**-Bedingung nicht zutrifft (also ```FALSE``` ergibt).
 
 ``` {r else, eval=TRUE}
@@ -152,7 +155,8 @@ Auch hier ist der Aufbau recht einfach:
 
 Dies waren einfache Beispiele von **if** und **else if**-Ausdrücken. In der Regel werden diese aber innerhalb von Schleifen genutzt (z.B. wenn man Entscheidungen für alle Beobachtungen innerhalb eines Datensatzes treffen möchte). Dies wird im Nachfolgenden gezeigt.
 
-## Loops
+# Loops
+
 Mit **Loops** (*Iterationen*) kann man Operationen wiederholen. Die Wiederholungen geschehen dabei *n*-Mal, wobei *n* ein ganzzahliger Laufwert ist (*integer*). Für die Wiederholungen gibt man einen Startwert fest. Wie oben bereits erwähnt, wendet man dies z.B. an, wenn man eigene Rekodierungen schreiben will ohne bereits bestehende Funktionen verwenden zu wollen.
 
 Wir können folgende Arten von Iterationen unterscheiden:
@@ -163,9 +167,8 @@ Wir können folgende Arten von Iterationen unterscheiden:
 
 3. **repeat** (**do while**)
 
-<br>
+## for
 
-### for
 In der **for**-Loop werden Operationen so lange durchgeführt, bis das Ende einer vordefinierten Sequenz erreicht ist (z.B. über alle Beobachtungen eines Datensatzes). Mit dieser Schleife setzen wir einen Beginn und ein Ende fest und die Operation werden innerhalb dieser Sequenz ausgeführt.
 
 Im Schaubild ist die Logik des **for-loops** dargestellt. 
@@ -174,9 +177,8 @@ Im Schaubild ist die Logik des **for-loops** dargestellt.
 ![for-loop](pics/for.PNG){width=50%}
 </center>
 
-<br>
+### Syntax
 
-#### Syntax
 Die allgemeine Syntax sieht wie folgt aus:
 ```{r for, eval=TRUE}
 for (i in 0:5) {
@@ -209,9 +211,8 @@ for (i in start:n) {
 }
 ```
 
-<br>
+### Beispiel for-loop
 
-#### Beispiel for-loop
 Wir schaffen eine einfache **for**-loop und geben dabei immer den Wert eines Vektors ```teacher``` aus, der die:den Dozentin:en für einen Kurs beinhaltet. Insgesamt haben wir $5$ Dozent:innen. Im Beispiel bestimmen wir das Ende der Schleife einfach über die Länge des Vektors, den wir nutzen. Denn wir möchten, dass alle Fälle durchgegangen werden. Wir geben nacheinander die Namen der Dozent:innen aus:
 
 ``` {r for3, eval=TRUE}
@@ -233,9 +234,8 @@ for (i in 1:length(teacher)) {
 ```
 Wir bedienen uns hierbei der Funktion ```paste0()```, die Text mit Objekten als Ausgabe verbinden kann. Die Funktion ```paste0()``` hat zwischen den Elementen in der Funktion keine Leerstelle (die Funktion ```paste()``` setzt zwischen allen Elementen ein Leerzeichen (oder ein im Argument ```sep``` angegebenes Trennzeichen.)
 
-<br>
+### for-loop mit else if-Ausdruck
 
-#### for-loop mit else if-Ausdruck
 Nehmen wir das Beispiel aus den **if**-Ausdrücken. Wir möchten nun eine neue Variable im Datensatz schaffen, die eine Wertebeschreibung nutzt. Wir benötigen also die **else if**-Bedingung aus dem vorherigen Kapitel und bilden nun um diese einen **for**-loop durch die Länge des Datensatzes. Das Ergebnis speichern wir in einer neuen Variable ```motText``` und lassen es für jeden Fall einzeln ausgeben (```print()```). Zur Anschaulichkeit gehen wir hier zwei Schritte: Wir speichern erst die Beschreibung in ```motivation``` und übertragen es dann an den Wert in ```statistics$motText```. **Wichtig ist**, dass wir nicht den Laufindex bei ```statistics$motText``` vergessen, da wir ja nur den spezifischen Fall mit dem neuen Wert belegen möchten.
 
 ```{r for-elseif, eval=TRUE}
@@ -262,9 +262,8 @@ for (i in 1:length(statistics$mot)) {
 
 **Eine kleine Aufgabe**: Wie oben genannt, haben wir unnötig viele Zeilen hier geschrieben. Probiere einmal die Schleife zu verschlanken!
 
-<br>
+### for-loop mit next
 
-#### for-loop mit next
 Als zweites Beispiel möchten wir nun eine neue Variable schaffen, die Beschreibungen von ```grade2``` in Abhängigkeit des Notenwertes inkludiert. Zur Erinnerung: Die Variable ```grade2``` weist ```NA's``` auf. Dies ist nur ein Funktionsbeispiel für die Kombination von **for**-loops und **if**-Ausdrücken. Es empfiehlt sich zum Rekodieren die Funktionen aus dem Paket ```dplyr``` (```case_when()```) oder ```car``` (```recode()```) zu nutzen. 
 
 ``` {r table, eval=TRUE}
@@ -303,25 +302,21 @@ table(statistics$g2text)
 
 **Eine kleine Aufgabe**: Anstatt ```next``` zu verwenden, könnte man hier auch mit nur mit **if**-Ausdrücken zum selben Ergebnis kommen. Schreibe die Schleife so um, dass diese ohne ```next``` auskommt.
 
-<br>
+### Vor- & Nachteile
 
-#### Vor- & Nachteile
 **for**-loops werden recht häufig genutzt und können auch verschachtelt werden. Nicht angewendet werden können **for**-loops, wenn die Anzahl der Durchläufe nicht bestimmbar ist ($\rightarrow$ **while**-loop). Ein Nachteil von **for**-loops ist, dass diese in der Regel sehr langsam sind. Auch ist es in verschachtelten **for**-loops oft nur schwer nachvollziehbar, was genau gemacht wird. Das heißt auch, dass die Fehlersuche manchmal mühsam sein kann. 
 
 Als Alternativen zu **for**-loops kann man die ```apply()```-Funktionen nutzen (Funktionalität ist durch Entwickler geprüft). Nähere Informationen zu den ```apply()```-Funktionen finden sich [hier](https://de.wikibooks.org/wiki/GNU_R:_apply). Dennoch können in manchen Situationen eigene geschrieben Funktionen auf **for**-loops zurückgreifen, so dass es sinnvoll ist, diese Grundfunktionen auch zu kennen.  
 
-<br>
-
-### while
+## while
 In der **while**-loop werden Instruktionen ausgeführt, solange eine Bedingung (*condition*) zutrifft. Man nennt dies auch **kopfgesteuert**: Denn bei jedem Durchlauf wird am Schleifenkopf die Bedingung neu geprüft. Wenn diese Bedingung (*condition*) nicht mehr zutrifft (```FALSE```), dann wird die **while**-loop beendet. Der Durchlauf von Code ist also abhängig von einer Bedingung. Sollte die Bedingung direkt zu Beginn nicht mehr zutreffen, wird der **while**-loop direkt beendet ohne auch nur eine Instruktion einmalig ausgeführt zu haben. 
 
 <center>
 ![while-loop](pics/while.PNG){width=50%}
 </center>
 
-<br>
+### Syntax
 
-#### Syntax
 Die allgemeine Syntax einer **while**-loop sieht wie folgt aus: 
 
 ```{r while, eval=TRUE}
@@ -342,9 +337,8 @@ Auch hier ist die Syntax wieder ähnlich zum **if**-Ausdruck:
 
 Wichtiger Unterschied zur **for**-loop: Die Sequenz wird hier nicht angegeben, es muss also innerhalb der Schleife das Inkrement angegeben werden (```i <- i + 1```). Passiert dies nicht, dreht sich die Schleife unendlich und man muss einen Programmabsturz erzwingen. Im Unterschied zur **for**-loop ist der Inkrement aber beliebig. Wir können also auch 
 
-<br>
+### Beispiel while-loop
 
-#### Beispiel while-loop
 Nehmen wir das Beispiel aus dem **for**-loop, das sich auch als **while**-loop darstellen lässt: 
 
 ``` {r while2, eval=TRUE}
@@ -394,18 +388,16 @@ while (pos <= length(teacher)) {
 
 Hier erhalten wir keine Ausgabe, da der **while**-loop direkt beendet wird. 
 
-<br>
+## repeat
 
-### repeat
 Im **repeat**-loop werden die Instruktionen mindestens einmal ausgeführt und zwar unabhängig davon, was die Bedingung ist. Die Bedingung (*condition*) wird nach Ausführung der Instruktionen geprüft. Dies nennt man **fußgesteuert**. Trifft sie zu (```TRUE```), wird der **repeat**-loop beendet. Trifft sie nicht zu (```FALSE```), erfolgt der nächste Durchlauf. Es ist sozusagen das Gegenteil der **while**-loop
 
 <center>
 ![repeat-loop](pics/repeat.PNG){width=50%}
 </center>
 
-<br>
+### Syntax
 
-#### Syntax
 Der Unterschied zur **while**-loop liegt darin, dass der **repeat**-loop (oder auch **do while**-loop) **fußgesteuert** ist (Bedingung wird nach jedem Durchgang geprüft).
 
 Die allgemeine Syntax ist ähnlich der Syntax zuvor mit einer kleinen Änderung: 
@@ -435,9 +427,8 @@ Auch hier gehen wir die Syntax wieder durch:
 
 Es wird also geprüft, ob ```i``` größer 5 ist: Trifft dies nicht zu, beginnt die Schleife von vorne, *repeated* sich also. Trifft dies zu, erfolgt die Anweisung zum Verlassen des loops mit ```break```. Vergisst man ```break``` zu setzen, läuft auch diese Schleife unendlich. In komplexeren **while**-loops kann ```break``` ebenfalls zum Abbruch der Schleife genutzt werden.
 
-<br>
+### Beispiel
 
-#### Beispiel
 Auch hier nehmen wir wieder das Beispiel aus der **for**-loop:
 ``` {r repeat2, eval=TRUE}
 teacher <- c("Baecker", 
@@ -467,12 +458,12 @@ repeat {
 
 **Zum Merken**: Im Unterschied zum **while**-loop geben wir die Abbruchbedingung mit **if** an. Ebenso müssen wir hier noch das Ende der **repeat**-loop mit ```break``` aufrufen. Andernfalls würde die Schleife unendlich (bzw. bis zum Programmabbruch durch den User) ohne Operationen weiterlaufen.
 
-## Funktionen in R schreiben
+# Funktionen in R schreiben
+
 In R können nicht nur die aus *packages* zur Verfügung gestellten Funktionen genutzt werden, es können auch sehr leicht eigene Funktionen geschrieben werden. Dazu werden wir zuerst eine eigene Funktion für die Berechnung des Mittelwertes anlegen und anschliessend eine Funktion zur Ausgabe des Interquartilsabstands berechnen. 
 
-<br> 
+## Syntax
 
-### Syntax
 Im Folgenden werden wir eigene Funktionen schreiben. Der grundlegende Aufbau des Codes ist wie folgt: 
 ```{r function}
 my_function <- function(arg1, arg2, ..., argn){
@@ -482,7 +473,7 @@ my_function <- function(arg1, arg2, ..., argn){
 
 Zuerst definieren wir einen Namen für die Funktion (```my_function```) und weisen dieser eine Funktion zu. In den runden Klammen ```()``` werden Argumente an die Funktion übergeben, die in den Anweisungen (alles in geschweiften Klammern ```{}```) genutzt werden. Dies können Datensätze, Variablen oder einzelne Werte sein. Es ist in Abängigkeit, wie man das Argument in den Anweisungen nutzt.
 
-### Eigene Funktion: Mittelwert
+## Eigene Funktion: Mittelwert
 Wir wollen nun mit einer selbstgeschriebenen Funktion den Mittelwert einer Variable berechnen. Dazu sollte der Datensatz ```statistics``` (oder ein beliebig anderer Datensatz mit einer metrischen Variable in das **environment** geladen werden). Wir schaffen eine Funktion, in der wir ein Argument übergeben: Die Variable, von der der Mittelwert berechnet werden soll. Dieses Argument benennen wir in der Funktion mit ```x```. Überall in den Anweisungen, wo wir ```x``` setzen, wird bei Aufruf der Funktion ```own_mean()``` das übergebene Argument genutzt. 
 
 Anschliessend berechnen wir in der ersten Anweisung der neuen Funktion den Mittelwert. Hierbei greifen wir das übergebene Argument (```x```) auf. Mit der zweiten Anweisung lassen wir diesen Wert ausgeben. Danach können wir die selbst geschaffene Funktion aufrufen und müssen hierbei das eine geforderte Argument (Variable der Berechnung) angeben. Der Mittelwert wird berechnet und mit ```return``` ausgegeben.
@@ -497,9 +488,9 @@ own_mean(statistics$grade)
 ```
 
 Somit haben wir die erste eigene Funktion geschrieben!
-<br>
 
-### Eigene Funktion: Interquartilsabstand
+## Eigene Funktion: Interquartilsabstand
+
 Nun wollen wir eine Funktion schreiben, die uns das untere und das obere Quartil ausgibt, sowie den Interquartilsabstand. Wir benötigen also **drei Anweisungen** in der Funktion: 
 
 1. die Berechnung des unteren Quartils,
@@ -592,7 +583,7 @@ test
 
 Das Schreiben eigener Funktionen ist in R leicht umzusetzen und ist in vielen Schritten der Datenanalyse hilfreich, wenn es keine bereits existenten Funktionen für spezifische Anwendungen gibt. 
 
-### Funktionen und Schleifen
+# Funktionen & Schleifen
 Wir können Schleifen auch gut in Funktionen nutzen. Wir könnten uns zum Beispiel eine Funktion schreiben, die uns die Abweichung vom Mittelwert und den Wert aus einer Variable anzeigen lässt. Dazu nehmen wir wieder den Beispieldatensatz ```statistics```.
 
 Wir verknüpfen jetzt die Funktion mit einem **for**-loop und einem **if**-Ausdruck. Wir benennen die Funktion ```showcase``` und übergeben ein Argument (die Variable, die genutzt werden soll). Anschliessend wird der **for**-loop gestartet. Wenn kein Wert vorliegt, wird eine Nachricht ausgegeben, dass kein Wert vorliegt. Wenn ein Wert vorliegt, wird der Abstand zum *mean* berechnet und dieser zusammen mit dem erreichten Wert ausgegeben.
diff --git a/slides/stringr-grammar.Rmd b/slides/stringr-grammar.Rmd
index 52562c7..21dde7c 100644
--- a/slides/stringr-grammar.Rmd
+++ b/slides/stringr-grammar.Rmd
@@ -1,7 +1,6 @@
 ---
 title: "Textdaten bearbeiten mit **stringr**"
-author: "B. Philipp Kleer"
-date: "11. Oktober 2021"
+
 output: 
   html_document:
       toc: true
@@ -10,9 +9,10 @@ output:
         smooth_scroll: true
       toc_depth: 3
       widescreen: true
-      highlight: pygments
-      theme: readable
-      css: styles/style.css
+      highlightStyle: github
+      highlightLines: true
+      highlightLanguage: ["r"]
+      css: styles/htmlbook.css
       df_print: paged
       mathjax: default
       self_contained: false
@@ -62,7 +62,7 @@ htmltools::tagList(
 :::: {class="flex-container"}
 
 ::: {class="flex-text"}
-In diesen Slides wollen wir uns mit Textdaten beschäftigen. Hieru lernen wir grundlegende Funktionen im Umgang mit Textdaten kennen. Eins vorweg: Textdaten sind immer schwieriger zu händeln als numerische Daten. Hierz werden im späteren Teil auch **regular expressions** eingeführt. Dies bleibt aber auf einem Grundlevel, weiterführend wird dazu sicherlich im Workshop zur quantitativen Textanalyse eingegangen.
+In diesen Slides wollen wir uns mit Textdaten beschäftigen. Hieru lernen wir grundlegende Funktionen im Umgang mit Textdaten kennen. Eins vorweg: Textdaten sind immer schwieriger zu händeln als numerische Daten. Hierzu werden im späteren Teil auch **regular expressions** eingeführt. Dies bleibt aber auf einem Grundlevel, weiterführend wird dazu sicherlich im Workshop zur quantitativen Textanalyse eingegangen.
 
 In R gibt es innerhalb des **tidyverse** ein spezielles Paket zur Bearbeitung von Textdaten: **stringr**. Gemeinsam mit *regular expressions* können viele Transformationen und Bereinigungen durchgeführt werden.
 
-- 
GitLab