erste_schritte_2.qmd

# Erste Schritte mit R, Teil 2

## Variablen

In R (wie auch in den meisten anderen Programmiersprachen) kann Daten (einzelne
Werte, aber auch Größeres) im Arbeitsspeicher ablegen und mit einem Namen versehen 
und so eine <span  class="imp">*Variable*</span> erzeugen.

Wir erstellen eine Variable mit dem Namen `a`, der wir den Wert 7 zuweisen:

```{r}
a <- 7
```

Die Variable wird nun im Environment (Teilfenster rechts oben in RStudio) aufgeführt.

Wir können den Wert der Variablen einsehen, indem wir ihren Namen verwenden:

```{r}
a
```

Wir können die Variable auch in arithmetischen Ausdrücken verwenden, z.B.:

```{r}
3*a + 1 
```
Hier ersetzt R die Variable `a` durch ihren Wert 7 und führt dann die Rechnung durch.

Der Begriff "Variable" rührt daher, dass man den Wert einer Variablen ändern kann,
einfach, indem man einen neuen Wert zuweist:

```{r}
a <- 10
```

Derselbe Ausdruck wie zuvor ergibt nun ein anderes Ergebnis:

```{r}
3*a + 1
```

<div class="imp">
Der Pfeil `<-` heisst "Zuweisungs-Operator" (*assignment operator*). Er weist einer
Variablen einen Wert zu (*assigns a value to a variable*). 

Der Pfeil kann auch andersherum geschrieben werden. Er weist stets vom Wert zum 
Variablen-Namen:

```{r}
a <- 10
```

ist dasselbe wie

```{r}
10 -> a
```

Als dritte Möglichkeit kann man auch
```{r}
a = 10
```
schreiben, d.h., `=` wird wie `<-` gelesen.
</div>

### Beispiel: Die Lösungsformel für quadratische Gleichungen:

Sicher erinnern Sie sich an diese Formel aus der Schule, um die Lösungen der 
quadratischen Gleichung $ax^2 + bx + c = 0$ zu finden:

$$ x_{1;2} = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} $$

Wir schreiben die Formel in R-Notation. Zunächst lesen wir das "$\pm$" als "+":

```r
( -b + sqrt( b^2 - 4*a*c ) ) / ( 2*a )
```

Wenn wir dies ausführen, beschwert sich R: `Error: object 'b' not found`

R kann den Ausdruck nicht ausrechnen, da nur für `a` ein Wert vorliegt, nicht aber 
für `b` (und auch nicht für `c`).

Lösen wir die Gleichung $3x^2 + 5x - 3 = 0$. Wir weisen die Werte der Koeffizienten 
Variablen zu, die die Namen `a`, `b` und `c` tragen:

```{r}
a <- 3
b <- 5
c <- -3
```

Nun liefert under Ausdrick die erste Lösung
```{r}
( -b + sqrt( b^2 - 4*a*c ) ) / ( 2*a )
```

Die zweite Lösung finden wir, indem wir das "$\pm$" als "$-$" schreiben:

```{r}
( -b - sqrt( b^2 - 4*a*c ) ) / ( 2*a )
```

*[Die erste Vorlesung endete hier. Der Rest kommt nächste Woche.]*

### Namen

Der Name einer Variable muss kein einzelner Buchstabe sein:

```{r}
ein_langer_name <- 15
```

Auch so ein langer Name kann in einem Ausdruck stehen:

```{r}
2 * ein_langer_name + 1
```

<div class="imp">
Für die Variablen-Namen (fachsprachlich *identifiers*) gelten folgende Regeln:

- Nur Buchstaben und Ziffern sind erlaubt, sowie der Unterstrich (`_`) und der 
  Punkt (`.`).
  
- Der Name darf nicht mit einer Ziffer beginnen.
</div>

### Aufgabe

Berechnen Sie die beiden Lösungen der quadratischen Gleichung $2x^2 - 3x - 6\frac{1}{2} = 0$. Weisen Sie
die beiden Lösungen den Variablen `x1` und `x2` zu. Setzten Sie dann die Variablen in die Gleichung
ein, um zu prüfen, ob man wirklich 0 erhält ("Probe").

Was geschieht, wenn Sie in der Gleichung den konstanten Term von $-6$ auf $6$ abändern? Warum?

## Etwas mehr Terminologie

### Ausdrücke

In R-Code wie z.B. `a <- 2*3` nennt man den Teil rechts, also `2*3` einen "Ausdruck" (*expression*). Ein Ausdruck ist also Code, der zu einem Wert ausgewertet werden kann. (*An expression is code that can be evaluated to a value.*) Ein Ausdruck kann dann z.B. einer Variablen zugewiesen werden (`a <- 2*3`), oder es kann auch Teil eiens größeren Ausdrucks sein (`sqrt(2*3)`).

Betrachten wir den Ausdruck `2*a + sqrt(3)`.

Hier sehen wir alle Komponenten, aus denen man einen Ausdruck zusammen bauen kann:

- Literale (*literals*), d.h. explizit angegebenen Werten (hier: `2` und `3`)
- Variablen (*variables*), für die R beim Auswerten ihren Wert einsetzt (hier: `a`)
- Operatoren (*operators*), d.h., Zeichen, die eine Rechenoperation durchführen, die zwei Ausdrücke verknüpft. (In unserem Beispiel verknüpft der Multiplikations-Operator `*` das Literal `2` und die Variable `a` und der Additions-Operator `+` verknüpft die Teilausdrücke `2*a` und `sqrt(3)`.)
- Funktionsaufrufe (*function calls*): In unserem Beispiel ist das `sqrt(3)`
- Wie erwähnt, kann man Teilausdrücke in runde Klammern setzen, um klar zu stellen, was zusammen ausgewertet werden soll, besonders, wenn man von Punkt-vor-Strich abweichen will.

Ein einzeln stehender (Literal-)Wert oder eine einzeln stehende Variable gelten auch als Ausdruck.

Leerzeichen oder Zeilenumbrüche zwischen den

### Funktionsaufrufe

Wir sehen uns Funktionsaufrufe noch mal genauer an.

Hier runden wir $pi$ auf drei Nachkommastellen:

```{r}
round( 3.14159265, 3 )
```

Ein Funktionsaufruf besteht immer aus dem *Funktionsnamen* (hier: `round`), gefolgt von einem Paar runder Klammern
(*parentheses*, *parens*), die die *Funktionsargumente* (*arguments*) enthalten. Für jedes Argument ist ein Ausdruck anzugeben. Wenn eine Funktion mehrere Argumente erwartet, müssen die Ausdrücke durch Kommas getrennt werden. 

Die Funktion `round` erwartet zwei Argumente, nämlich erst die zu rundende Zahl und dann die Anzahl der Nachkommastellen. 

Wenn man `?round` angibt, erscheint die *Hilfeseite* für `round`. Dort finden wir die "Signatur" der Funktion:

```r
round(x, digits = 0, ...)
```

Dies bedeutet: Das erste Argument heisst `x`, das zweite `digits`. Weiter unten steht, wie die Argumente interpretiert werden. (`x` ist die zu rundende Zahl, `digits` die Anzahld er Nachkommastellen.)

Für `digits` gibt es einen sog. Vorgabe-Wert (sog. *default value*), der durch das `= 0` angegeben ist. Das bedeutet, dass man dieses Argument weg lassen darf (*optional argument*), und das R dann den Default-Wert (hier 0, also keine Nachkommastellen) dafür einsetzt:

```{r}
round( 3.14159265 )
```

Die Argumente müssen entweder in genau der Reihenfolge übergeben werden, in der sie in der Signatur stehen (*positional arguments*) oder man gibt die Argument-Namen wie folgt mit an (*named arguments*). Dann darf man von der Reihenfolge abweichen:

```{r}
round( digits=3, x=3.14159265 )
```

Das `...` bedeutet (vereinfacht gesagt), dass es evtl. weitere Argumente gibt (die man nur mit Angabe des Argument-Namens verwenden darf).

### Boolsche Ausdrücke

Betrachten Sie diesen Ausdruck:

```{r}
3 < 7
```

Hier wurde der Vergleichs-Operator `<` ("kleiner") verwendet. Da der Wert links von `<` tatsächlich kleiner
ist als der Wert rechts, ist der Ausdruck "wahr" (`TRUE`). Dies ist ein Wert, genauso wie `3` oder `-2.765`

Man kann ihn also einer Variablen zuweisen:

```{r}
a <- 3 < 7
a
```

Solche Werte nennt man "Wahrheitswerte", "logische Werte" (*logical values*) oder
Boolsche Werte (*Boolean values*, nach dem Mathematiker George Boole)

Logische Werte entstehen z.B., wenn man Vergleichoperatoren verwendet. Es gibt folgende:

- `<` und `>` stehen für "kleiner als" und "größer als"
- `<=` und `>=` stehen für "kleiner oder gleich" (sonst $\le$ geschrieben) und "größer oder gleich" ($\ge$)
- `==` bedeutet "gleich". Beachte, dass man `==` schreiben muss, den `=` ist der Zuweisungsoperator (s.o.)
- `!=` ist wie man "ungleich" ($\neq$) tippt

### Datentypen

Jeder Ausdruck hat einen Daten-Typ (*data type*):

Normale Zahlen haben den Typ "<span class="imp">numeric</span>", auch "double" genannt. ("Double" steht für
"double-precision floating-point number"; das ist das Standardformat, in dem Computer Kommazahlen speichern.)

Die Funktion `class` zeigt den Datentyp ihres Arguments an:

```{r}
class(3.14)
```

Machmal findet man auch den Typ "<span class="imp">integer</span>" (Ganzzahl).

Die eben erwähnten Boolschen Ausdrücke haben den Datentyp "<span class="imp">logical</span>"

```{r}
class( 7 > 3 )
```

```{r}
class( TRUE )
```

## Character strings

Wichtig ist auch der Typ "Zeichenkette" (engl. *string of characters*, in der
Informatik normalerweise kurz als *string* bezeichnet, in R aber abgekürzt als
*"<span class="imp">character</span>"*):

```{r}
s <- "hello"
class(s)
```

<div class="imp">
Eine Zeichenkette muss stets in Anführunsgzeichen (double quotes, `"..."`) gesetzt werden.
</div>

Wenn man
```r
s <- hello
```
schreibt, denkt R, dass man eine Variable mit dem Namen `hello` meint und beschwert sich, dass
diese nicht definiert wurde.

Vergleichen Sie

```{r}
ss <- "a"
ss
```

```{r}
ss <- a
ss
```

Mit Zeichenketten kann man natürlich nicht rechnen:

```r
"Hello" + 17
```

Hier beschwert sich R: `Error in "Hello" + 17 : non-numeric argument to binary operator`, d.h.,
es bemängelt, dass "Hello" keine Zahl ist und man damit nicht addieren kann.

Es gibt aber Funktionen, die Strings als Argumente erwarten. Zum Beispiel

`nchar` (number of characters) zählt, wie viele Zeichen der String enthält:

```{r}
nchar( "Hello" )
```

Die Funktion `toupper` ("to upper case")wandelt einen String in Grossbuchstaben (engl. "upper-case letters") um:
```{r}
toupper( "Hello" )
```

So fügt man mehrere Strings zu einem String zusammen:
```{r}
paste( "Hello", "world" )
```

Wir werden noch weiter solche Funktionen kennen lernen

## Vektoren

<div class="imp">Daten kommen selten allein. Mit der Funktion `c` (für "concatenate") können wir mehrere Werte 
(desselben Datentyps) zu einem sog. "Vektor" zusammenstellen:</div>

```{r}
v <- c( 3, 5, 2, 7, -1, 2.5, 3 )
```

Die Variable `v` enthält nun nicht einen Wert sondern sieben:

```{r}
v
```

<div class="imp">Wir können mit eckigen Klammern (*square brackets*) auf einzelne Werte
zugreifen, z.B. auf den vierten Wert (immer von links):

```{r}
v[4]
```
</div>

### Vektor-Operationen

Viele Operationen in R können auch mit Vektoren arbeiten. Hier zählen wir
z.B. zu jedem Wert in `v` 1 hinzu:

```{r}
v+1
```

Oder wir fragen, welche Werte größer als 3 sind:

```{r}
v > 3
```

und erhalten eine Vektor von "logical"-Werten.

Nun verwenden wir die Funktion `seq` (für "sequence"), um einen Vektor zu erzeugen,
der die Zahlen von 1 bis 7 enthält, und weisen dies der Variablen `w` zu:

```{r}
w <- seq(7)
w
```

Nun können wir die beiden Vektoren `v` und `w` Element für Element (*element-wise*) addieren:

```{r}
v + w
```

(Beachten Sie das beide Vektoren gleich viele Element haben.)

Funktionen wirken oft auch *element-wise*.

Beispiel: Wir schieben jedes Element in `v` durch die Exponentialfunktion $e^x$:

```{r}
exp(v)
```

Beipsiel 2: Die Quadratwurzeln der Zahlen in `v`:

```{r}
sqrt(v)
```

Hier bekommen wir eine Warnung, weil der 5. Wert nicht ebstimmt werden konnte (da 
die Quadratwurzel von negativen Zahlen nicht definiert ist). Statt dessen wird die
"Pseudo-Zahl" NaN (für "not a number") in den Eregnis-Vektor eingetragen.

Wir können die Zahlen in v auch der Größe nach sortieren:

```{r}
sort(v)
```

### Terminologie

- Die einzelnen Werte in einem Vektor heißen "Elemente" (*elements*).
- Die Anzahl der Elemente eines Vektors ist seine Länge (*length*).
- Die Position eines Elements ist sein "Index" (*index*).
- Auch ein Vektor istb ein Ausdruck oder kann Teil eiens Ausdrucks sein.
- Ein einzelner Wert heißt "Skalar" (*scalar*)

In den meisten Programmiersprachen wird streng unterschieden zwischen Skalaren
und Vektoren der Länge 1. Ein Vektor ist ein andere Datentyp als ein Skalar. In R 
ist das nicht so: Alles ist ein vektor, und ein skalarer Wert ist einfach 
ein Vektor der Länge 1.

Deshalb steht vor allen Werten immer ein `[1]`. Es zeigt an dass das Element mit 
dem Index 1 folgt (und bisher war das meist das einzige Element des Vektors).

Bei langen Vektoren sehen wir auch andere Index-Angaben. Hier ein Vektor mit den Zahlen von 100 bis 130:

```{r}
seq( 100, 130 )
```

### Reduzierende Funktionen

In den Beispielen von oben war das Ergebnis aller Audrücke mit Vektoren stets ein Vektor mit ebensovielen
Elementen wie der Vektor, den wir in die Rechnung hinein gegeben haben.

Es gibt aber auch Funktionen, die eine Vektor mit mehreren Elementen zu einem
einzelnen Wert zusammen fassen, sog. zusammenfassende Funktionen (*summarising fucntions*),
auch reduzierene Funktionen (*reducing functions*) genannt.

Wichtigstes Beispiel ist die Bildung des Mittelwertes (*average* oder *mean*). Hierzu dient die Funtkion `mean`:

```{r}
mean( v )
```

Häufig möchte man auch einfach alle Elemente aufaddieren. Die Funktion hierfür heißt `sum`:

```{r}
sum( v )
```

Wir können auch den Median berechnen:

```{r}
median( v )
``` 
Dies bedeutet, dass ebenso viele Zahlen in `v` größer als 3 sind wie Zahlen kleiner
als 3 sind, also 3 in der Mitte liegt, wenn man den Vektor sortierte.

Andere gerne verwendete Statistiken sind Varianz (*variance*) und Standard-Abweichung 
(*standard deviation*, SD), die durch die Funktionen `var` und `sd` berechnet werden:

```{r}
var( v )
sd( v )
```

Auch `length` ist eine summarising function. Sie zählt einfach, wie viele Elemente
der Vektor enthält:

```{r}
length( v )
```

### Aufgaben

#### Mittelwert "per Hand"

Die Funktion `sum` addiert alle Elemente eines Vektors auf und liefert ihre Summe.
Den Mittelwert berechnet man bekanntlich, indem man die Summe durch die Anzahl der
Werte teilt. Berechnen Sie den Mittelwert von `v` auf zwei Wege: zum einen
mittels `mean`, zum anderen mittels `sum` und `length`.

#### "kleiner Gauß"

Was ist die Summer der ganzen Zahlen von 1 bis 100?

#### Standardabweichung per Hand

Die Stichproben-Varianz wird bekanntlich wie folgt berechnet:

$$ v = \frac{1}{n-1}\sum_{i=1}^n \left( x_i - \overline x \right)^2 $$
Hier ist $\overline x$ der Mittelwert der Einzelwerte $x_i$ und $n$ die Anzahl der Einzelwerte.

Berechnen Sie die Stichprobenvarianz von `v` mit dieser Formel. Bestimmen Sie also erst
den Mittelwert $\overline x$, ziehen Sie ihn von allen Einzelwerten ab, quadrieren Sie die
so erhaltenen Werte, und addieren Sie alle diese Quadrate. Teilen Sie schließlich die Summe durch
$n-1$. Bauen Sie diese Formel schritt für Schritt, von innen nach außen, auf, und testen Sie
jeden Schritt, bevor Sie den nächsten vornehmen.

Vergleichen Sie mit dem Ergebnis der `var`-Funktion.

### Erzeugung von Vektoren

Wir haben zwei Methoden zur Erzeugung von Vektoren besprochen: `c` und `seq`.

Hier noch einige weitere Details hierzu:

Mit der Funktion `c` kann man nicht nur einzelne Elemente, sondern auch mehrere Vektoren
zusammen fassen. Der folgende Ausdruck hängt den Vektor `v` von zuvor, die Zahl `100`
und den Vektor `w` (mit den Zahlen von 1 bis 7) aneinander:

```{r}
c( v, 100, w )
```

Die Funktion `seq` kann auch noch mehr:

Mit einem Argument zählt sie bis zur angegeben Zahl:

```{r}
seq(7)
```

Mit zwei Argumenten zählt sie vom ersten zum zweiten Argument

```{r}
seq( 5, 10 )
```

Mit drei Argumenten kann man auch eine Schrittweite angeben. Hier zählen wir von 2 bis 6
in Schritten von jeweils 0.5:

```{r}
seq( 2, 6, 0.5 )
```

Die Form mit zwei Argumenten ist so häufig, dass es eine Abkürzung gibt: Statt `seq(5,10)`
kann man kurz `5:10` schreiben:

```{r}
5:10
```

#### Aufgabe: Sinuskurve

Erzeugen Sie einen Vektor `x` mit Zahlen von 0 bis 10  in Schritten zu je 0.1.
Berechnen Sie dann `y <- sin(x)`. Was finden Sie dann in y? Mit `plot( x, y )` können 
Sie es schnell heraus finden.

## Tabellen

Für diesen Abschnitt verwenden wir ein Beispiel auf Irizarrys Buch.

Wir laden dazu das Paket "dslab", dass die Beispieldaten aus dem Buch enthält.

```{r}
library( dslabs )
```
Denken Sie daran, dass Sie das Paket mit `install.packages("dslabs")` installieren
müssen, bevor Sie es zum ersten Mal laden können.

Dieses Paket enthält eine Variable namens `murders`. Wir lassen uns anzeigen, was
sie enthält:

```{r}
murders
```

Mit `?murders` können wir die zugehörige Hilfeseite aufrufen und erfahren so,
dass es sich um eine Tabelle mit der Anzahl an durch Feuerwaffen verübte
Morde im Jahr 2010 handelt, aufgeschlüsselt nach Staaten in den USA.

Der Typ dieser Variable is "data.frame":

```{r}
class(murders)
```

"Data frame" ist R's Weg, Tabellen zu speichern, nämlich als eine Liste von Vektoren. Jeder
Vektor stellt eine Spalte der Tabelle dar. Wir können auf die einzelnen Vektoren zugreifen, indem
wir den Spaltennamen hinter den Variablennamen stellen, getrennt durch ein Dollarzeichen (`$`):

Hier die erste Spalte:

```{r}
murders$state
```

Wir können die Spalte mit der Anzahl der Mordfälle (`total`) durch die Bevölkerung (`population`)
des jeweiligen Staates teilen:

```{r}
murders$total / murders$population
```

Nun haben wir die Mordrate per capita. Wir multiplizieren mit 1.000.000 (oder `1e6`),
um die Mordrate pro 1 Million Einwohner zu erhalten:

```{r}
murders$total / murders$population * 1e6
```

Das fügen wir nun als neue Spalte `murders_per_million` hinzu:

```{r}
murders$murders_per_million <- murders$total / murders$population * 1e6
```

Hier ist unsere neue Tabelle:

```{r}
murders
```


## Hausaufgaben

### Runden

Verschönern Sie die eben erstellte Tabelle mit der Mordstatistik, in dem Sie die Werte in der neuen Spalte
`murders_per_million` auf eine Nachkommestelle runden. (Erinnern Sie sich an die wieter oben eingeführte Funktion `round`.)

### Abspeichern

Speichern Sie die Tabelle mit der Mordstatistik in eine Datei ab, indem Sie die Funktion `write.csv` benutzen, z.B. so:
`write.csv( murders, "murders.csv" )`. Sie sollten dann auf Ihrer Festplatte eine Datei mit Namen `murders.csv`
finden. Laden Sie diese in Excel (oder einem anderen Tabellenkalkulationsprogramm).

### Plotten

Verwenden Sie die nochmals die Funktion `plot`. Übergeben Sie zunächst die Tabellenspalte mit der Einwohnerzahl als erstes Argument (x-Werte) und die Spalte mit der Anzal der Morde (`total`) als y-Achse. 

- Wie ändert sich der Plot, wenn Sie die Mord-Rate (Morde pro Million Einwohner) statt der Mord-Anzahl verwenden?

- Welcher "Staat" sticht dann hervor? Wo ist die Mordrate am höchsten? Können Sie das erklären?

- Ergänzen Sie im Aufruf der `plot`-Funktion als drittes Argument hinzu: `log="x"`. Was ändert sich? Ist das nützlich?

### R-Skript

Erstellen Sie ein R-Skript, dass die R-Anweisungen für die vorstehenden Aufgaben enthält. Das 
Skript sollte also die Mordstatstik-Tabelle laden, die Spalte mit der Mordrate hinzufügen
und dann einen der Plots erstellen. Speichen Sie das Skript ab.

Wählen Sie im Menü "Session" von RStudio erst die Menü-Funktion "Clear Workspace" und dann die Funktion
"Restart R" aus. Damit wird R in den Auusgangszustand zurückversetzt. Führen Sie alle Zeilemn Ihres Skripts
aus, um sich zu überzeugen, dass noch alles funkioniert und nichts fehlt.

Bitte laden sie die Datei mit dem Skript auf Moodle hoch.

### Installation Tidyverse

Bitte installieren bis zur nächsten Vorlesung die Tidyverse-Pakete für R. Dazu brauchen
Sie nur

```r
install.packages( "tidyverse" )
```

in der RStudio-Konsole einzugeben. Allerdings braucht die Installation ca. 5-10
Minuten, daher sollten Sie das vor der nächsten Vorlesung erledigt haben.