---
title: 'Übungszettel Arbeitsumgebung und Datentransformation'
author: "Johannes Brachem (johannes.brachem@stud.uni-goettingen.de)"
subtitle: "M.Psy.205, Dozent: Dr. Peter Zezula"
output:
  html_document:
    theme: paper
    toc: yes
    toc_depth: 3
    toc_float: yes
  pdf_document:
    latex_engine: xelatex
header-includes:
 - \usepackage{comment}
params:
 soln: TRUE
mainfont: Arial
linkcolor: blue
---


# Links

[Übungszettel als PDF-Datei zum Drucken](https://pzezula.pages.gwdg.de/sheet_environment_transformation.pdf)

`r if(!params$soln) {"\\begin{comment}"}`
**Übungszettel mit Lösungen**

[Lösungszettel als PDF-Datei zum Drucken](https://pzezula.pages.gwdg.de/sheet_environment_transformation_solutions.pdf)

[Der gesamte Übugszettel als .Rmd-Datei](https://pzezula.pages.gwdg.de/sheet_environment_transformation.Rmd) (Zum Downloaden: Rechtsklick > Speichern unter...)

`r if(!params$soln) {"\\end{comment}"}`

# Hinweise zur Bearbeitung

1. Bitte beantworten Sie die Fragen in einer .Rmd Datei. Sie können Sie über `Datei > Neue Datei > R Markdown...` eine neue R Markdown Datei erstellen. Den Text unter dem *Setup Chunk* (ab Zeile 11) können Sie löschen.
2. Informationen, die Sie für die Bearbeitung benötigen, finden Sie auf der [Website der Veranstaltung](https://www.psych.uni-goettingen.de/de/it/team/zezula/courses/multivariate)
3. Zögern Sie nicht, im Internet nach Lösungen zu suchen. Das effektive Suchen nach Lösungen für R-Probleme im Internet ist tatsächlich eine sehr nützliche Fähigkeit, auch Profis arbeiten auf diese Weise. Die beste Anlaufstelle dafür ist der [R-Bereich der Programmiererplattform Stackoverflow](https://stackoverflow.com/questions/tagged/r)
4. Auf der Website von R Studio finden Sie sehr [hilfreiche Übersichtszettel](https://www.rstudio.com/resources/cheatsheets/) zu vielen verschiedenen R-bezogenen Themen. Ein guter Anfang ist der [Base R Cheat Sheet](http://github.com/rstudio/cheatsheets/raw/master/base-r.pdf)

# Tipp der Woche
Mit der Tastenkombination `ctrl` + `alt` + `i` (Windows) oder `cmd` + `alt` + `i` (Mac) können Sie per Knopfdruck ein neues R-Code-Feld (*Chunk*) in R-Markdown Dateien erstellen.

# Aufgabe 1: R Markdown
## a) Neue Markdown Datei öffnen
1. Laden Sie unter diesem Link [unter diesem Link](https://pzezula.pages.gwdg.de/students_template.Rmd) unsere Vorlage für die Erstellung von R-Markdown Dokumenten zur Bearbeitung unserer Übungszettel herunter.(Hinweis: Sie können auch eine neue .Rmd Datei erstellen, indem Sie auf `Datei > Neue Datei > R Markdown...` klicken. Mit unserer Vorlage ist der Start aber vermutlich einfacher.)
2. Speichern Sie die Datei unter einem sinnvollen Namen in einem sinnvollen Ordner ab. In diesem Ordner sollten Sie bestenfalls in der Folge alle .Rmd-Dateien für die Bearbeitung der Übungszettel speichern. Öffnen Sie nun die Datei.
3. Lassen Sie die Datei mit `Strg` + `Shift` + `K` (Windows) oder `Cmd` + `Shift` + `K` (Mac) rendern. Sie sollten nun im "Viewer" unten rechts eine "schön aufpolierte" Version ihrer Datei sehen. 


## b) Code-Chunks benutzen
1. Erstellen Sie einen R-Code-Chunk mit `ctrl` + `alt` + `i` (Windows) oder `cmd` + `alt` + `i` (Mac)
2. Tippen Sie `5 + 3` in den grau hinterlegten Code-Chunk. Führen Sie die Zeile aus, indem Sie `strg` + `enter` (Windows) oder `cmd` + `enter` drücken. Das Ergebnis, `8` sollte Ihnen in der Konsole nun angezeigt werden.
3. Tippen Sie `test <- 5 + 3` in eine neue Zeile in den Code-Chunk und führen Sie auch diese Zeile aus. Das Ergebnis sollte Ihnen diesmal nicht direkt angezeigt werden, stattdessen haben Sie im *Workspace* oben rechts ein neues Objekt namens "test".
4. Tippen Sie nun `test` in eine neue Zeile in den Code-Chunk und führen Sie sie aus. Nun sollte Ihnen das Ergebnis wieder in der Konsole (unten links) angezeigt werden.
5. Tippen Sie nun `# test anzeigen` in die **gleiche Zeile wie in der vorherigen Aufgabe** und führen Sie die Zeile erneut aus. Sie können sehen, dass die keinen Effekt hatte: `#` kennzeichnet *Kommentare*, alles was hinter einem `#` steht, wird nicht ausgerechnet. Dies ist nützlich für (kurze!) Erklärungen. Längere Erklärungen sollten außerhalb der *Chunks* als normaler Text geschrieben werden.
6. Klicken Sie auf `Tools > Global Options` und wählen Sie auf der linken Seite "R Markdown" aus. Überprüfen Sie, ob das Häkchen bei "*Show Output inline for all Markdown documents*" gesetzt ist. Wenn ja, **entfernen Sie es**. Das Häkchen sollte **nicht** gesetzt sein.

## c) Arbeitsverzeichnis setzen
Wenn Sie Dateien in R einlesen möchten, oder aus R abspeichern möchten, ist es wichtig, dass Sie ein Arbeitsverzeichnis verwenden. Das ist der Ordner auf ihrem Computer, in dem R nach Dateien sucht, und in dem R Dateien abspeichert.

1. Setzen Sie das Arbeitsverzeichnis, indem Sie oben auf `Session > Set Working Directory > To Source File Location` klicken.
2. Betrachten Sie die Konsole (unten links). Sie sehen dort einen Befehl, der ähnlich wie dieser aussieht: `setwd("P:/mv")`
3. Kopieren Sie diesen Befehl und fügen ihn in den dafür vorgesehenen Code-Chunk am Anfang ihrer .Rmd-Datei ein. Nun können Sie immer, wenn Sie die Datei erneut öffnen, diesen Befehl ausführen und dadurch automatisch das richtige Arbeitsverzeichnis setzen. **Achtung**: Das funktioniert natürlich nur, wenn Sie immer den gleichen Ordner auf Ihrem Computer verwenden.

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung
(Bitte folgen Sie den Anweisungen in der Aufgabenstellung und melden Sie sich beim Problemen.)
`r if(!params$soln) {"\\end{comment}"}`

# Aufgabe 2: Pakete

1. Installieren Sie das Paket-System `tidyverse`, indem Sie `install.packages("tidyverse")` ausführen. Zu diesem System gehören mehrere sehr nützliche Pakete, z.B. `dplyr` für Datenaufbereitung und `ggplot2` für Plots. Hinweis: Auf den PCs im CIP-Pool müssen Sie diesen Befehl nicht ausführen, die Pakete sind installiert.

2. Laden Sie das Paket-System `tidyverse` mit dem Befehl `library(tidyverse)`. Sie sollten nun diese Anzeige bekommen, die Ihnen sagt, welche Pakete standardmäßig zum `tidyverse` gehören. Diese werden automatisch mitgeladen. Schreiben Sie den Syntaxbefehl zum Laden in den dafür vorgesehenen Code-Chunk am Anfang der .Rmd-Datei.
```{r echo = FALSE}
library(tidyverse)
```

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung
#### Teilaufgabe 1
```{r eval = FALSE}
# der Befehl unten wird nicht ausgeführt, weil im Chunk eval = FALSE gesetzt ist 
# und daher nicht ausgeführt wird beim Rendern
# install.packages() macht in einem RMD, das von seiner Konzeption her wir immer wieder laufen können soll, keinen Sinn
install.packages("tidyverse")
```

#### Teilaufgabe 2
```{r}
library(tidyverse)
```
`r if(!params$soln) {"\\end{comment}"}`

# Aufgabe 3: Mit Objekten umgehen
## a) Erstellen von Objekten
Erstellen Sie die folgenden Objekte:

1. Einen Vektor `a1`, der die Zahlen von 1 bis 5 enthält.
2. Einen Vektor `a2` der die Zahlen von 0 bis 4.5 in Schritten von 0.5 enthält (d.h. er beinhaltet 10 Zahlen).
3. Einen Vektor `a3` der Länge 10, der Zahlen von 0 bis 85 in gleichmäßigen abständen enthält.
4. Eine Matrix, die die Zahlen 1 bis 9 in drei Zeilen enthält. Sie sollte so aussehen:
```{r echo=FALSE}
a4 <- matrix(1:9, byrow = TRUE, ncol = 3)
a4
```

5. Einen `tibble`-Datensatz namens `a5`, der die beiden Vektoren `a2` und `a3` enthält.

*Hinweis: `tibble`s sind moderne Formen von `data.frame`s. Wir empfehlen, dass Sie immer `tibble`s verwenden. Wenn Sie Daten mit den `readr`-Befehlen `read_csv()` oder `read_delim()` einlesen, werden diese automatisch als `tibble` gespeichert.*

6. Einen `tibble`-Datensatz namens `a6`, der die beiden Vektoren `a2` und `a3` enthält. Bei diesem `data frame` sollten Sie bei der Erstellung die beiden Vektoren umbenennen: Nennen Sie `a2` "motivation" und `a3` "result"
7. Eine Liste `a7`, die alle bisher erstellen Elemente beinhaltet.

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung
#### Teilaufgabe 1
Schneller als die Schreibweise per Hand ist hier die Eingabe mit dem Doppelpunkt: `:`.

`0:5` bedeutet zum Beispiel *0 bis 5* und ist das gleiche wie `c(1, 2, 3, 4, 5)`.

```{r}
a1 <- c(1, 2, 3, 4, 5) # lange Schreibweise
a1 <- 1:5 # kurze Schreibweise
```

#### Teilaufgabe 2
Der Befehl seq() mit dem Argument "by" ist hier hilfreich
```{r}
a2 <- seq(from = 0, to = 4.5, by = 0.5)
```

#### Teilaufgabe 3
Der Befehl seq() mit dem Argument "length.out" ist hier hilfreich
```{r}
a3 <- seq(from = 0, to = 85, length.out = 10)
```

#### Teilaufgabe 4
Der Befehl matrix() hilft hier weiter.
`byrow = TRUE` sorgt für die Zeilenweise Befüllung und `ncol = 3` sorgt dafür, dass die Matrix 3 Spalten hat.

```{r}
a4 <- matrix(1:9, byrow = TRUE, ncol = 3)
```

#### Teilaufgabe 5
Mit dem Befehl tibble() können Sie tibble-Datensätze erstellen. Die Objekte, die Sie damit in einem Datensatz verbinden, müssen die gleiche Anzahl von Zeilen haben.
```{r}
a5 <- tibble(a2, a3)
```

#### Teilaufgabe 6
Sie können die einzelnen Elemente eines tibbles direkt bei der Erstellung benennen.
```{r}
a6 <- tibble(motivation = a2, result = a3)
```

#### Teilaufgabe 7
Mit dem Befehl list() können Sie Listen erstellen. Diese können Objekte verschiedner Art und Länge enthalten. Listen begegnen uns als PsychologInnen im Alltag meist nur als Output von Analysen. Wir müssen nicht oft selbst welche erstellen, aber es lohnt sich, sie zu kennen.
```{r}
a7 <- list(a1, a2, a3, a4, a5, a6)
```

`r if(!params$soln) {"\\end{comment}"}`

## b) Auf Elemente zugreifen

1. Greifen Sie auf das dritte Element des Vektors `a1` zu.
2. Greifen Sie auf die dritte Spalte der Matrix `a4` zu.
3. Greifen Sie abermals auf die dritte Spalte der Matrix `a4` zu. Sorgen Sie diesmal dafür, dass die Dimensionen der Matrix erhalten bleiben. Das Ergebnis sollte wie folgt aussehen:
```{r echo = FALSE}
a4[,3, drop = FALSE]
```

4. Greifen Sie auf die zweite bis sechste Zeile des data.frame `a6` zu.
5. Greifen Sie auf die Spalte / Variable `result` im data.frame `a6` zu.

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung

#### Teilaufgabe 1
```{r}
a1[3]
```

#### Teilaufgabe 2
In Matrizen (und Datensätzen/tibbles) können Sie ebenfalls mit eckigen Klammern hinter dem Objektnamen auf die einzelnen Elemente des Objektes zugreifen. Beachten Sie hier: Die Zahl vor dem Komma gibt die ausgewählten Zeilen an, die Zahl nach dem Komma die Spalten. Wenn Sie alle Zeilen auswählen wollen, geben Sie nichts vor dem Komma ein.
```{r}
a4[,3]
```

#### Teilaufgabe 3
Wenn Sie nur eine Zeile einer Matrix auswählen, macht `R` automatisch einen Vektor daraus. Um dieses Verhalten zu verhindern, können Sie die Option `drop = FALSE` an den Auswahl-Befehl anhängen.
```{r}
a4[,3, drop = FALSE]
```

#### Teilaufgabe 4
Der Doppelpunkt-Operator funktioniert auch für den Zugriff auf ELemente.
```{r}
a6[2:6,]
```

#### Teilaufgabe 5
Mit dem `$`-Operator können Sie auf benannte Spalten innerhalb von tibbles/Datensätzen und Listen zugreifen.
```{r}
a6$result
```
`r if(!params$soln) {"\\end{comment}"}`

## c) Objekte manipulieren
1. Addieren Sie `3` zu jedem Element des Vektors `a1` und speichern das Ergebnis unter dem Namen `c1`
2. Erstellen Sie einen neuen tibble `c2`, indem Sie nur die Zeilen 3 und 4 aus dem tibble `a6` auswählen.

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung
#### Teilaufgabe 1
```{r}
c1 <- a1 + 3
```

#### Teilaufgabe 2
Mit dem Zuweisungspfeil `<-` speichern Sie das Ergebnis eines Befehls unter einem Namen ab. So können Sie auch bestehende Objekte überschreiben. 
*Hinweis*: Sie müssen nicht den Doppelpunkt `:` benutzen, alternativ können Sie auch `a6[c(3,4),]` schreiben. Diese Schreibweise ist äquivalent und kann zusätzlich benutzt werden, um Zeilen auszuwählen, die nicht benachbart sind, z.B. würde `a6[c(1,3,5),]` die Zeilen 1, 3 und 5 auswählen.
```{r}
c2 <- a6[3:4,]
```


`r if(!params$soln) {"\\end{comment}"}`

# Aufgabe 4: Logische Abfragen

1. Greifen Sie auf alle Zeilen des Datensatzes `a6` zu, bei denen `result` größer als 50 ist.
2. Greifen Sie auf alle Zeilen des Datensatzes `a6` zu, bei denen `result` zwischen 30 und 70 liegt.
3. Greifen Sie auf alle Zeilen des Datensatzes `a6` zu, bei denen `result` *kleiner* als 30, oder *größer* als 70 ist.
4. Nutzen Sie sum() und eine logische Abfrage, um die Anzhal von Zeilen in `a6` zu erhalten, bei denen `result` größer als 20 ist.

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung

#### Teilaufgabe 1
Der `>` Operator heißt *größer als*.
```{r}
a6[a6$result > 50, ]
```

#### Teilaufgabe 2
Der `&` Operator heißt *und*.
```{r}
a6[30 < a6$result & a6$result < 70,]
```

#### Teilaufgabe 3
Der `|` Operator heißt *oder*.
```{r}
a6[30 > a6$result | a6$result > 70,]
```

#### Teilaufgabe 4
Wenn man logische Werte addiert, gil "TRUE" = 1 und "FALSE" = 0.
```{r}
sum(a6$result > 20)
```
`r if(!params$soln) {"\\end{comment}"}`


# Aufgabe 5: Daten einlesen
1. Laden Sie den Datensatz *seatbelts.csv* [hier herunter](https://pzezula.pages.gwdg.de/data/seatbelts.csv). Legen Sie diese Datei in einen Ordner namens "data" in Ihrem Ordner für die Statistik-Übungszettel.

2. Lesen Sie den Datensatz *seatbelts.csv* mit dem Befehl `read_csv()` ein und speichern Sie ihn in R unter dem Namen `seatbelt_data`. Tipp: Wenn Sie die Datei wie in 5.1 beschrieben in einem Unterordner "data" in Ihrem Arbeitsverzeichnis abgespeichert haben, ist der Pfad zur Datei für Sie nun `"data/seatbelts.csv"`.
  
*Hinweis: `read_csv` und `read.csv` sind unterschiedliche Befehle. `read_csv` ist die modernere Variante und wird von uns empfohlen. Mehr können Sie bei Interesse [hier](http://readr.tidyverse.org/articles/readr.html) erfahren.*

3. Schauen Sie sich kurz die Bedeutung der Variablen in diesem Datensatz an. [Unter diesem Link](https://stat.ethz.ch/R-manual/R-devel/library/datasets/html/UKDriverDeaths.html) finden Sie eine kurze Beschreibung.

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung
#### Teilaufgabe 1
(Bitte folgen Sie den Anweisungen im Aufgabentext.)

#### Teilaufgabe 2
Die Meldung, die Sie ausgegeben bekommen, zeigt Ihnen an, in welchem *Objekttyp* R die einzelnen Variablen in Ihrem Datensatz eingelesen hat. Das Programm versucht automatisch, einen passenden Typ zu wählen. Falls Sie unerwartete Probleme mit Ihren Daten bekommen, können Sie den Objekttyp im Funktionsaufruf von `read_csv()` oder seinen verwandten `read_delim()` manuell auswählen. In diesem Fall hilft Ihnen ein Blick in die Hilfe durch `?read_csv` zum Argument `col_types`.

Beim Einlesen von Daten müssen Sie darauf achten, dass Sie im richtigen Verzeichnis arbeiten. Hier liegt die Datei `seatbelts.csv` im Unterordner "data" unseres Arbeitsverzeichnisses, deshalb geben wir das bei dem Funktionsaufruf mit an.

```{r}
# seatbelt_data <- read_csv("data/seatbelts.csv")
# as the above depends on the real download, we do it via direct access
seatbelt_data <- readr::read_csv("https://md.psych.bio.uni-goettingen.de/mv/data/div/seatbelts.csv")
```

#### Teilaufgabe 3
(Bitte folgen Sie den Anweisungen im Aufgabentext.)

`r if(!params$soln) {"\\end{comment}"}`

# Aufgabe 6: Mit der Pipe `%>%` umgehen.

1. Schreiben Sie den folgenden Befehl um, so dass Sie `%>%` verwenden, um den Code besser lesbar zu machen.
```{r eval = FALSE}
filter(seatbelt_data, year == 1969)
```

2. Schreiben Sie den folgenden Befehl ebenfalls mit der Pipe ` %>% ` um, um ihn besser lesbar zu machen.
```{r eval = FALSE}
select(filter(seatbelt_data, year == 1969, kms > 10000), DriversKilled)
```

3. Nehmen Sie Ihren Code von Aufgabe 6.1 und nutzen Sie ihn, um ein *Subset* von `seatbelt_data` namens `seatbelt_data_69` zu erzeugen, in dem nur die Daten aus dem Jahr 1969 enthalten sind.

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung
#### Teilaufgabe 1
Es lohnt sich zusätzlich, nach jeder *Pipe* einen Zeilenumbruch einzusetzen. So ist ihr Code noch einmal deutlich besser lesbar.
```{r}
seatbelt_data %>% 
  filter(year == 1969)
```

#### Teilaufgabe 2
Innerhalb eines `filter()` Befehls können Sie mehrere Bedingungen per Komma aneinanderreihen.
```{r}
seatbelt_data %>% 
  filter(year == 1969, kms > 10000) %>% 
  select(DriversKilled)
```

#### Teilaufgabe 3
Wie alle anderen Befehle auch, müssen Operationen mit der *Pipe* durch den Zuweisungspfeil `<-` abgespeichert werden, um sie zu sichern. Ansonsten werden Sie nur angezeigt, aber nichts weiter geschieht.
```{r}
seatbelt_data_69 <- seatbelt_data %>% 
  filter(year == 1969)
```

`r if(!params$soln) {"\\end{comment}"}`

# Aufgabe 7: Mit `dplyr` umgehen

**Hinweise**

* Bitte nutzen Sie wann immer möglich die piping-Schreibweise mit ` %>% ` für diese und ähnliche Aufgaben. Dies ist in unser aller Interesse, da so die Lesbarkeit und Nachvollziehbarkeit ihres Codes maximiert wird.
* Lassen Sie sich über `?<funktion>` die Hilfe-Seite zu den vorgeschlagenen Funktionen anzeigen. Dort sehen sie alle Befehle, die Sie in einer Funktion verwenden können. Zum Beispiel zeigt Ihnen `?arrange` die Hilfe-Seite zum Befehl `arrange` an. (Da es mehrere Funktionen namens "arrange" gibt, müssen Sie zunächst per Klick auswählen, zu welcher Sie sich die Hilfe anzeigen lassen wollen.)

***

**Aufgaben**

1. Nutzen Sie den Befehl `filter()`, um sich alle Daten aus dem Monat *Januar* im Datensatz `seatbelt_data` anzeigen zu lassen.
2. Nutzen Sie den Befehl `select()`, um sich außerdem nur die Daten zu `DriversKilled`, `law`, `year` und `month` anzeigen zu lassen.
3. Nutzen Sie den Befehl `mutate()`, um eine neue Variable namens `id` zu erstellen, die die Zahlen von 1 bis 192 enthält. Überschreiben Sie `seatbelt_data` mit dem Ergebnis.
4. Nutzen Sie den Befehl `arrange()`, um den Datensatz anhand von `id` *abwärts* zu sortieren.
5. Nutzen Sie den Befehl `group_by()`, um im unbearbeiteten Datensatz `seatbelt_data` die Daten nach Jahren zu gruppieren. Nutzen Sie anschließend `summarize()`, um sich die mittlere Anzahl von Todesfällen pro Jahr anzeigen zu lassen.
6. Nutzen Sie den Befehl `rename()`, um die Variable `DriversKilled` in `drivers_killed` und `PetrolPrice` in `petrol_price` umzubennen. 

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung
#### Teilaufgabe 1
```{r}
seatbelt_data %>% 
  filter(month == "Jan")
```

#### Teilaufgabe 2
```{r}
seatbelt_data %>% 
  select(DriversKilled, law, year, month)
```

#### Teilaufgabe 3
```{r}
seatbelt_data <- seatbelt_data %>% 
  mutate(id = 1:192)
```

#### Teilaufgabe 4
```{r}
seatbelt_data %>% 
  arrange(desc(id))
```

#### Teilaufgabe 5
```{r}
seatbelt_data %>% 
  group_by(year) %>% 
  summarise(mean_deaths = mean(DriversKilled))
```

#### Teilaufgabe 6
```{r}
seatbelt_data <- seatbelt_data %>% 
  rename(drivers_killed = DriversKilled,
         petrol_price = PetrolPrice)
```


`r if(!params$soln) {"\\end{comment}"}`

# Aufgabe 8: Long & Wide Data

Es ist für fast alle Vorgänge in R am besten, wenn Sie Daten im *long*-Format haben. Das liegt einfach an der Art, wie R funktioniet.

Wide-Data sieht so aus:
```{r echo = FALSE}
wide_data <- tibble(subj = 1:4, 
                    gender = c("m", "m", "f", "f"), 
                    t1 = c(2,3,4,5), 
                    t2 = c(6,5,4,3))

wide_data
```

Long-Data sieht so aus (dies sind die gleichen Daten):
```{r echo = FALSE}
wide_data %>% gather(t1:t2, key = time, value = value)
```

In der Psychologie sind unsere Roh-Daten oft im *wide*-Format. Das Paket `tidyr` bietet die Möglichkeit, diese Daten einfach in das *long*-Format zu bringen. Genaueres dazu können Sie [hier finden](https://blog.rstudio.com/2014/07/22/introducing-tidyr/).

***

**Aufgaben**

1. Führen Sie den unten stehenden Befehl aus, um den Datensatz `wide_data` zu erzeugen.

```{r eval = FALSE}
wide_data <- tibble(subj = 1:4, 
                    gender = c("m", "m", "f", "f"), 
                    t1 = c(2,3,4,5), 
                    t2 = c(6,5,4,3))
```

2. Nutzen Sie den Befehl `gather()` mit den Optionen `key` und `value`, um einen Datensatz `long_data` zu erzeugen. Dieser sollte genau so aussehen, wie im Beispiel oben. 

`r if(!params$soln) {"\\begin{comment}"}`
### Lösung
#### Teilaufgabe 1
```{r}
wide_data <- tibble(subj = 1:4, 
                    gender = c("m", "m", "f", "f"), 
                    t1 = c(2,3,4,5), 
                    t2 = c(6,5,4,3))
```

#### Teilaufgabe 2
```{r}
long_data <- wide_data %>% 
  gather(t1:t2, key = time, value = value)
```


`r if(!params$soln) {"\\end{comment}"}`

# Aufgabe 9: Rendern (knit)
Lassen Sie die Datei wie in Aufgabe 1 a)3 mit `Strg` + `Shift` + `K` (Windows) oder `Cmd` + `Shift` + `K` (Mac) rendern. Sie sollten nun im "Viewer" unten rechts eine "schön aufpolierte" Version ihrer Datei sehen. Falls das klappt: Herzlichen Glückwunsch! Ihr Code kann vollständig ohne Fehlermeldung gerendert werden. Falls nicht: Nur Mut, das wird schon noch! Vielleicht schaffen wir es ja in der Übung gemeinsam.


# Literatur
*Anmerkung*: Diese Übungszettel basieren zum Teil auf den "Smart Alex" Aufgaben aus dem Lehrbuch *Dicovering Statistics Using R* (Field, Miles & Field, 2012). Sie wurden für den Zweck dieser Übung modifiziert, und der verwendete R-Code wurde aktualisiert.

Field, A., Miles, J., & Field, Z. (2012). *Discovering Statistics Using R*. London: SAGE Publications Ltd.

Version: `r format(Sys.time(), '%d %B, %Y %H:%M')`