---
title: "Die Varianzanalyse"
author: "Jonathan Harrington"
date: "29. Mai 2018"
output: html_document
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```
```{r,echo = FALSE}
pfadu = "http://www.phonetik.uni-muenchen.de/~jmh/lehre/Rdf"
```
Das Package `dplyr` gegebenenfalls bitte installieren (sollte schon passiert sein, sofern Sie die Übungen bearbeitet haben):
```{r,eval=FALSE}
install.packages("dplyr")
```
```{r,message=FALSE}
library(dplyr)
zweit = read.table(file.path(pfadu, "zweit.df.txt"))
```

## 1. Grundfunktionen in `dyplr`: die sogenannten "Verben"

Ein Grundprinzip von `dyplr` ist es, komplexe Aufgaben in eine Abfolge einfacher Aufgaben aufzuteilen, und diese einfachen Aufgaben auf besonders effektive Art und Weise zu lösen. Ein möglicherweise zunächst als Nachteil empfundener Effekt hiervon ist, dass der `dplyr`-Code für eine Aufgabe in `R` zunächst als (unnötig?) lange Kette von Befehlen erscheint; der große Vorteil hiervon ist jedoch, dass eine komplexere Aufgabe "in Worte gefasst" wird, und man auf diese Weise vergleichsweise leichtverständliche Teilaufgaben, die quasi-natürlichsprachlich formuliert sind, einfach kombinieren kann. Ein wichtiger Teil dieser Prozesses ist der Umstand, dass die eigentlichen Aufgaben als "Verben" verstehbar sind. Die für uns wichtigsten dieser "Verben" sind:

|`dplyr`-Verb |Beschreibung|
|------------|:------------------:|
|`select()`|wähle Spalte(n)|
|`slice()`|wähle Reihe(n)|
|`filter()`|filtere Reihe(n)|
|`arrange()`|ordne Reihen um|
|`mutate()`|erzeuge neue Spalten|
|`summarise()` bzw. `summarize()`|fasse mehrere Werte zu einem zusammen|
|`group_by()`|gruppiere nach Faktorstufen|

Die genannten Befehle können nur mit Dataframes umgehen, und sie geben als Ergebnis immer einen Dataframe aus (der manchmal `tibble` genannt wird und etwas anders aussieht, da u.a. die Datentypen der Spalteninhalte angezeigt werden; das muss uns an dieser Stelle aber nicht weiter kümmern: ein `tibble` ist nur eine moderne Variante eines Dataframes).

Diese "Verben" können als Teil eines "Satzes" verwendet werden (innerhalb einer sogenannten Pipe, s.u.),
aber auch als eigenständige Befehle; im letzteren Fall ist das erste Argument der Dataframe, mit dem etwas gemacht werden soll.

### 1.1 Beispiele 
####1.1.1 `select()`

```{r}
head(zweit)
zweitVpnG = select(zweit,Vpn,G) # wähle aus dem Dataframe "zweit" die Spalten "Vpn" und "G"
head(zweitVpnG)
```

####1.1.2 `slice()`

```{r}
slice(zweit,1:3) #die ersten drei Zeilen
```

####1.1.3 `filter()`

```{r}
filter(zweit,l1score>=120) # nur die Zeilen, in denen ein l1score größer oder gleich 120 vorkommt
```

####1.1.4 `arrange()` (und Gebrauch von `desc()`)

```{r}
zl1up = arrange(zweit,l1score) # ordne nach den Werten in l1score, aufsteigend
head(zl1up)
```
Durch `desc()` (für "descending" im Sinne von "descending order") kann man die Reihenfolge umkehren:
```{r}
zl1down = arrange(zweit,desc(l1score)) # ordne nach den Werten in l1score, absteigend
head(zl1down)
```

####1.1.5 `mutate()`

```{r}
zweitdiff = mutate(zweit,diffl2l1=l2score-l1score) # erzeuge eine neue Spalte namens "diffl2l1"", die die Differenz der Werte in den Spalten "l2score" und "l1score" enthält
head(zweitdiff)
```

####1.1.6 `summarise()` (bzw. `summarize()`)

Das "Verb" `summarise()` wendet eine Funktion an, um aus vielen Werten einen zu erzeugen. Dies funktioniert aber nur mit den Funktionen `first()`, `last()`, `nth()`, `n()`, `n_distinct()`, `IQR()`, `min()`, `max()`,`mean()`,`median()`,`var()`,`sd()`; die wichtigsten davon (für diesen Kurs) sind:

```{r}
summarise(zweit,min(l1score)) # zeige den kleinsten Wert der Spalte l1score
summarise(zweit,max(l1score)) # zeige den größten Wert der Spalte l1score
summarise(zweit,mean(l1score)) # zeige das arithmetische Mittel der Werte der Spalte l1score
summarise(zweit,mean(l1score)) # zeige den Medianwert der Spalte l1score
summarise(zweit,sd(l1score)) # zeige die Stichprobenstandardabweichung der Werte der Spalte l1score
summarise(zweit,IQR(l1score)) # zeige den Interquartilsabstand (also den Abstand zwischen dem 75%-Quantil und dem 25%-Quantil) der Werte der Spalte l1score
```

####1.1.7 `group_by()`
 Die Gruppierung, die durch `group_by()` vorgenommen wird, sieht man so nicht, denn es wird einfach der Dataframe in `tibble`-Form wieder ausgegeben, ohne das irgendetwas verändert wurde:
```{r}
group_by(zweit,Ses) # gruppiere nach den Faktorstufen in Ses: low, mid, high
```

`group_by()` wird aber dann höchst sinnvoll, wenn man etwas pro Gruppe machen will:

```{r}
summarise(group_by(zweit,Ses),mean(l2exposure)) #berechne pro Faktorenstufe in Ses das arithmetische Mittel der Werte in der Spalte l2exposure
```

Da der Ausdruck `summarise(group_by(zweit,Ses),mean(l2exposure))` sehr lang ist, und daher etwas schwer verständlich, ist es einfacher, so etwas in Unteraufgaben aufzuteilen. Ein solches Verfahren - das sehr ähnlich wäre wie die Aufteilung in Unteraufgaben, wie wir sie aus dem package `ggplot2` kennen - gibt es auch in dplyr.

##2. Modularisierung mittels des "Pipe"-Operators `%>%`

Man kann eine Aufgabe wie "berechne pro Faktorenstufe in Ses das arithmetische Mittel der Werte in der Spalte l2exposure" in *einen* komplexen Ausdruck wie `summarise(group_by(zweit,Ses),mean(l2exposure))` schreiben, kann dessen Teile aber auch einzeln aufführen, und diese durch die Verwendung des "pipe"-Operators `%>%` zu einem Ganzen zusammenführen:

```{r}
summarise(group_by(zweit,Ses),mean(l2exposure))

#oder besser lesbar:

zweit %>% # nimm den Dataframe "zweit"
  group_by(Ses) %>% # teile diesen in Gruppen (basierend auf den Faktorstufen in Spalte "Ses") ein und tue alles Nachfolgende pro Gruppe
  summarise(mean(l2exposure)) # berechne das arithmetische Mittel der Werte in der Spalte "l2exposure"

```

Die generelle Schreibweise ist also 

`dataframe $>$ funktion(Spalte)`

mit der Bedeutung: "Nimm aus dem Dataframe `dataframe` die Spalte `Spalte` und führe damit die Funktion `funktion` aus"; ohne Modularisierung sähe der Befehl folgendermaßen aus:

`funktion(dataframe,Spalte)`

Man kann - wie die Unteraufgaben in ggplot2 auch - beliebig viele einzelne Aufgaben kombinieren; wegen der Lesbarkeit kann man diese einzelnen, durch `$>$` verknüpften Befehle untereinander schreiben, man kann aber auch alles in eine Zeile packen:

```{r}
zweit %>%
  group_by(Ses) %>%
  summarise(mean(l2exposure)) 

# oder

zweit %>% group_by(Ses) %>% summarise(mean(l2exposure)) 
```

Eine etwas komplexere Aufgabe könnte z.B. so aussehen:

"Berechnen Sie die gruppenspezifischen (Spalte Ses) Stichprobenstandardabweichungen der Differenzen aus den Scores für die Zweit- und die Erstsprache (Spalten l2score bzw. l1score) im Dataframe 'zweit'!"

Diese Aufgabe kann man folgendermaßen in einfache Unteraufgaben aufteilen:

- a) nimm den Dataframe 'zweit'
- b) errechne eine neue Spalte mit dem Namen 'diffl2l1', die die Differenzen der Spaltenwerte in 'l2score' und 'l1score' enthält
- c) gruppiere nach den Faktorstufen in Ses
- d) errechne die Stichprobenstandardabweichung für diffl2l1

In modularisierender `dplyr`-Schreibweise:

```{r}
zweit %>% # a)
  mutate(diffl2l1 = l2score - l1score) %>% # b)
  group_by(Ses) %>% # c)
  summarise(sd(diffl2l1)) # d)
```

N.B.: in diesem Fall wären b) und c) auch vertauschbar:

```{r}
zweit %>% # a)
  group_by(Ses) %>% # c)
  mutate(diffl2l1 = l2score - l1score) %>% # b)
  summarise(sd(diffl2l1)) # d)
```


##3. Link zum `dplyr`-cheat sheet

https://github.com/rstudio/cheatsheets/raw/master/data-transformation.pdf