---
fontsize: 8pt
bibliography: 2_Referenzen.bib
citation_package: natbib
output:
  beamer_presentation:
    keep_tex: true
    includes:
      in_header: 2_header.tex
---


```{r, include = F}
source("2_R_common.R")
```

#  {.plain}
\center
```{r, echo = FALSE, out.width = "20%"}
knitr::include_graphics("2_Abbildungen/pds_2_otto.png")
```

\vspace{2mm}

\huge
Programmierung und Deskriptive Statistik
\vspace{6mm}

\large
BSc Psychologie WiSe 2021/22

\vspace{6mm}
\large
Prof. Dr. Dirk Ostwald

#  {.plain}

\vfill
\huge
\begin{center}
(2) R und RStudio Grundlagen
\end{center}
\vfill

#
\large
\vfill
\setstretch{2.5}

R und RStudio

Arithmetik, Logik und Präzedenz

Variablen

Datenstrukturen

Übungen und Selbstkontrollfragen


#
\large
\vfill
\setstretch{2.5}

**R und RStudio**

Arithmetik, Logik und Präzedenz

Variablen

Datenstrukturen

Übungen und Selbstkontrollfragen

# R und RStudio
\setstretch{1.6}
\large
\textcolor{darkblue}{Was ist R?}

\normalsize
Eine Programmiersprache und ein Softwarepaket.

Entwickelt von @ihaka_language_1996.

Freier Dialekt der propietären Software S (@becker_new_1988).

Weiterentwickelt und gepflegt durch
[R Core Team](https://www.r-project.org/contributors.html) und
[R Foundation](https://www.r-project.org/foundation/)

Interpretierte imperativ-objektorientierte 4GL Sprache.

Optimiert und populär für statistische Datenanalysen.

Große Community mit etwa 20.000 beigetragenen R Paketen (Erweiterungen)

Evolviert und konservativ im Kern, konsistent und progressiv in
[R Paketen](https://cran.r-project.org/web/packages/).


# R und RStudio
\large
\textcolor{darkblue}{Wie bekommt man R?}
\normalsize

Runterladen (z.B. \url{https://cran.r-project.org/bin/windows/base/}) und installieren.
\vspace{2mm}


```{r, echo = FALSE, out.width = "80%"}
knitr::include_graphics("2_Abbildungen/pds_2_r_download.png")
```


# R und RStudio
\setstretch{1.5}
\large
\textcolor{darkblue}{Was kann man mit R machen?}
\normalsize

Datensätze laden, manipulieren, und speichern.

Eine Vielzahl von Berechnungen an verschiedenen Datenstrukturen durchführen.

Eine Vielzahl statistischer Analysemethoden auf Daten anwenden.

Datenanalyseskripte schreiben und Abbildungen generieren.

Präsentationen [RMarkdown](https://bookdown.org/yihui/rmarkdown/) und
Bücher [RBookdown](https://bookdown.org/yihui/bookdown/) erstellen.

\vspace{2mm}

\large
\textcolor{darkblue}{Was kann man mit R (bisher) nicht so gut machen?}
\normalsize

In einer ansprechenden Umgebung programmieren ($\Rightarrow$ RStudio).

Scientific Computing ($\Rightarrow$ Python, Matlab, Julia).

Psychologische Experimente programmieren ($\Rightarrow$ Python, Matlab)



# R und RStudio
\large
\textcolor{darkblue}{Wie bekommt man Hilfe zu R?}
\normalsize

Googlen

\url{https://stackoverflow.com/}

Während der Programmierung und bei bekanntem Funktionsnamen

```{r, eval = F, echo = T}
?mean
help(mean)
```

Für längere Tutorials
```{r, eval = F, echo = T}
browseVignettes()
```

\url{https://rseek.org/}


\url{https://www.rstudio.com/resources/cheatsheets/}

\url{https://www.r-bloggers.com/}


# R und RStudio
\setstretch{1.6}
\large
\textcolor{darkblue}{Was ist RStudio?}
\normalsize

Eine Softwareentwicklungsumgebung für R

Softwareentwicklungsumgebung = Integrated Development Environment

IDEs sind Programme zum Programmieren mit einer Programmiersprache

Kommandozeile, Skripteditor, Vielzahl weiterer Tools

Freemium Produkt von RStudio, Inc. (IDE frei, Server kostenpflichtig)

Initial Release 2011, Affero General Public License

Keine Verbindung zu R Core Team oder R Foundation



# R und RStudio
\large
\textcolor{darkblue}{Wie bekommt man RStudio?}
\vspace{1mm}

Runterladen (\url{https://www.rstudio.com/products/rstudio/}) und installieren
\vspace{2mm}

```{r, echo = FALSE, out.width = "80%"}
knitr::include_graphics("2_Abbildungen/pds_2_rstudio_download.png")
```


# R und RStudio
\setstretch{1.6}
\vspace{2mm}
\large
\textcolor{darkblue}{Was kann man mit RStudio machen?}
\normalsize

R Skripte erzeugen, bearbeiten, und laufen lassen

R Skripte in R Projekten organisieren

Laut Eigenwerbung

\small

* Access RStudio locally
* Syntax highlighting, code completion, and smart indentation
* Execute R code directly from the source editor
* Quickly jump to function definitions
* View content changes in real-time with the Visual Markdown Editor
* Easily manage multiple working directories using projects
* Integrated R help and documentation
* Interactive debugger to diagnose and fix errors
* Extensive package development tools


# R und RStudio
\large
\textcolor{darkblue}{Was kann man mit RStudio machen?}
\normalsize

Custom Layout via Tools $\rightarrow$ Global Options ...

```{r, echo = FALSE, out.width = "90%"}
knitr::include_graphics("2_Abbildungen/pds_2_rstudio.png")
```


# R und RStudio
\large
\textcolor{darkblue}{Wie bekommt man Hilfe zu RStudio?}

\normalsize
Googlen

Zur Einführung $\Rightarrow$ [Using the RStudio IDE](https://support.rstudio.com/hc/en-us/sections/200107586-Using-the-RStudio-IDE)

```{r, echo = FALSE, out.width = "70%"}
knitr::include_graphics("2_Abbildungen/pds_2_using_rstudio.png")
```

# R und RStudio
\setstretch{1.7}
\large
\textcolor{darkblue}{R Kommandozeile $\vert$ Working in the Console}
\normalsize

Eingabe von R Befehlen bei $>$

Autocomplete mit Tab

Vorherige Befehle mit Cursor $\uparrow$

Bereinigen des Konsolenoutputs mit Ctrl + L

Code Ausführungsstopp mit Esc

```{r, echo = T, eval = T}
print("Hallo Welt!")
```

**Code-Snippets in diesen Folien immer aktiv in der Konsole nachvollziehen!**


# R und RStudio
\setstretch{1.4}
\large
\textcolor{darkblue}{R Skripte $\vert$ Executing and Editing Code}
\small

File $\rightarrow$ New File $\rightarrow$ R Script oder Ctrl + Shift + N für neue .R Datei

Open File oder Ctrl + O zum Öffnen bestehender .R Datei

Eintippen von

```{r, eval = F}
print("Hallo Welt!")  # Hinter Hashtags stehen dokumentierende Kommentare
print("Hallo R!")     # Kommentare werden nicht ausgefuehrt
```

Ausführen der einzelnen Zeile, auf welcher der Cursor ruht

$\Rightarrow$ Run oder Ctrl + Enter

Ausführen aller Zeilen

$\Rightarrow$ Source oder Ctrl + Shift +  Enter oder

$\Rightarrow$ Tickmark bei Source on Save setzen und Ctrl + S

**Code-Snippets in diesen Folien immer aktiv in einem R Skript dokumentieren!**


# R und RStudio
\setstretch{1.4}
\large
\textcolor{darkblue}{Das R und RStudio Data Science Universum}
\vspace{2mm}

```{r, echo = FALSE, out.width = "100%"}
knitr::include_graphics("2_Abbildungen/pds_2_rstudio_datascienceuniverse.pdf")
```

# R und RStudio
\setstretch{1.4}
\large
\textcolor{darkblue}{Lehrmaterialien mit R und RStudio}
\vspace{2mm}

```{r, echo = FALSE, out.width = "80%"}
knitr::include_graphics("2_Abbildungen/pds_2_lehrmaterialien.pdf")
```



#
\large
\vfill
\setstretch{2.5}

R und RStudio

**Arithmetik, Logik und Präzedenz**

Variablen

Datenstrukturen

Übungen und Selbstkontrollfragen


# Arithmetik, Logik und Präzedenz
\textcolor{darkblue}{R Konsole als Taschenrechner}
\footnotesize
\vspace{1mm}

```{r}
1+1
```
```{r}
2*3
```
```{r}
sqrt(2)
```
```{r}
exp(0)
```
```{r}
log(1)
```

\begin{itemize}
\item $[1]$ zeigt das erste und einzige Element des Ausgabevektors an
\item Vektoren werden noch im Detail behandelt.
\end{itemize}


# Arithmetik, Logik und Präzedenz
\textcolor{darkblue}{Arithmetische Operatoren}
\vspace{4mm}
\setstretch{1.6}

\small
\begin{center}
\begin{tabular}{l|l}
Operator 			& Bedeutung 							\\\hline
$+$ 				& Addition 								\\
$-$ 				& Subtraktion 							\\
$*$ 				& Multiplikation 						\\
$/$ 				& Division 								\\
\^{} oder $**$    	& Potenz             					\\
\%$*$\% 			& Matrixmultiplikation 					\\
\%$/$\% 		    & Ganzzahlige Teilung (5\%$/$\%2 = 2)	\\
\%\% 			    & Modulo (5\%\%2 = 1)   				\\
\end{tabular}
\end{center}
\vspace{4mm}

* Matrixmultiplikation, Modulo, ganzzahlige Teilung benötigen wir zunächst nicht.
* Ganzzahlige Teilung gibt das Resultat der ganzzahligen Teilung an.
* Modulo gibt den ganzzahligen Rest bei ganzzahliger Teilung an.




# Arithmetik, Logik und Präzedenz
\setstretch{1.6}
\textcolor{darkblue}{Logische Operatoren}
\small

Die Boolesche Algebra und R kennen zwei logische Werte: TRUE und FALSE

Bei Auswertung von Relationsoperatoren ergeben sich logische Werte

\small
\begin{center}
\begin{tabular}{l|l}
Relationsoperator 	& Bedeutung 							\\\hline
$==$ 				& Gleich 								\\
$!=$ 				& Ungleich 								\\
$<$, $>$			& Kleiner, Größer 						\\
$<=$, $>=$ 			& Kleiner gleich, Größer gleich			\\
$\vert$    			& ODER              					\\
$\&$    			& UND              						\\
\end{tabular}
\end{center}

* $<,<=,>,>=$ werden zumeist auf numerische Werte angewendet.
* $==,!=$ werden zumeist auf beliebige Datenstrukturen angewendet.
* $\vert$  und $\&$ werden zumeist auf logische Werte angewendet.
* Die Funktion xor() implementiert das exklusive ODER.

# Arithmetik, Logik und Präzedenz
\textcolor{darkblue}{Mathematische Funktionen}
\setstretch{1.4}

\small
\begin{center}
\begin{tabular}{l|l}
Aufruf				& Bedeutung 								\\\hline
abs(x) 				& Betrag 									\\
sqrt(x) 			& Wurzel 									\\
ceiling(x)			& Aufrunden (ceiling(2.7) = 3)				\\
floor(x)		   	& Abrunden (floor(2.7) = 2)             	\\
round(x)  			& Mathematisches Runden	(round(2.5) = 2)	\\
exp(x) 				& Exponentialfunktion						\\
log(x)				& Logarithmus Funktion						\\
\end{tabular}
\end{center}

Es handelt sich um eine Auswahl, einen vollständigen Überblick gibt

```{r, eval = F}
names(methods:::.BasicFunsList)
```

R unterscheidet formal nicht zwischen Operatoren und Funktionen

Operatoren können mit der Infix Notation als Funktionen genutzt werden

```{r}
`+`(2,3)            # Infixnotation für 2 + 3
```



# Arithmetik, Logik und Präzedenz
\textcolor{darkblue}{Operatorpräzedenz}
\small

Operatorrangfolge

Regeln der Form "Punktrechnung geht vor Strichrechnung"

Vordefinierte Operatorpräzedenz kann durch Klammern überschrieben werden

```{r}
2 * 3 + 4
```

```{r}
2 * (3 + 4)
```

Generell gilt

* Operatorrangfolge nicht raten oder folgern, sondern nachschauen!
* Lieber Klammern setzen, als keine Klammern setzen!
* Immer nachschauen, ob Berechnungen die erwarteten Ergebnisse liefern!

```{r, eval = F, indent = "     "}
?Syntax
```


# Arithmetik, Logik und Präzedenz
\textcolor{darkblue}{Operatorpräzedenz}

Präzedenz und Ausführungsreihenfolge arithmetischer Operatoren

\small

\begin{center}
\begin{tabular}{l|l}
Operator			& Reihenfolge 								\\\hline
\^{} 				& Rechts nach links							\\
$-$x,$+$x			& Unitäres Vorzeichen, links nach rechts	\\
$*$, $/$			& Links nach Rechts							\\
$+$, $-$			& Links nach Rechts							\\
\end{tabular}
\end{center}

Beispiele
\footnotesize
```{r, eval = F}
2^2^3 			# 2^(2^3)  	= 2^8 = 256
(2^2)^3			# (2^2)^3  	= 4^3 = 64
-1^2 			# -(1^2)   	= -1
(-1)^2 			# (-1)^2   	=  1
2+3/4*5 		# 2+(3/4)*5 = 2+(0.75*5) = 2+3.75 = 5.75
2+3/(4*5)		# 2+3/(4*5) = 2+3/20 = 2+0.15 = 2.15
```


# Arithmetik, Logik und Präzedenz
\textcolor{darkblue}{Operatorpräzedenz}

```{r, echo = FALSE, out.width = "70%"}
knitr::include_graphics("2_Abbildungen/pds_2_precedence.pdf")
```


#
\large
\vfill
\setstretch{2.5}

R und RStudio

Arithmetik, Logik und Präzedenz

**Variablen**

Datenstrukturen

Übungen und Selbstkontrollfragen

# Variablen
\textcolor{darkblue}{Definition}
\vspace{5mm}

\small
In der Programmierung ist eine Variable ein abstrakter Behälter für eine Größe,
welche im Verlauf eines Rechenprozesses auftritt. Im Normalfall wird eine Variable
im Quelltext durch einen Namen bezeichnet und hat eine Adresse im Speicher
einer Maschine. Der durch eine Variable repräsentierte Wert kann – im Unterschied
zu einer Konstante – zur Laufzeit des Rechenprozesses verändert werden.

\begin{flushright}
\textit{Wikipedia}
\end{flushright}


# Variablen
\normalsize
\textcolor{darkblue}{Grundlagen}
\small

Variablen sind vom Programmierenden benannte Platzhalter für Werte

In 3GL Sprachen wird der Variablentyp durch eine Initialisierungsanweisung festgelegt:

```{r, eval = F}
VAR A : INTEGER     # A ist eine Variable vom Typ Integer (ganze Zahl)
```


In 3GL Sprachen wird Variablen durch eine Zuweisungsanweisung ein Wert zugeschrieben:

```{r, eval = F}
A := 1              # Der Variable A wird der numerische Wert 1 zugewiesen
```

In 4GL Sprachen wie Matlab, Python, R werden Variablen durch Zuweisung initialisiert:
```{r, eval = F}
a = 1               # a ist eine Variable vom Typ double, ihr Wert ist 1
```

Der Zuweisungsbefehl in Matlab und Python ist `=`, der Zuweisungsbefehl in R ist `<-`  oder `=`.

Offiziell empfohlen für R ist `<-`, aus Kohärenzgründen benutzen wir hier `=`.


# Variablen
\textcolor{darkblue}{Beispiel}
\vspace{2mm}

\footnotesize
\justifying
Greta geht ins Schreibwarengeschäft und kauft vier Hefte, zwei Stifte und einen Füller. 
Wie viele analoge Gegenstände kauft Greta insgesamt?

```{r}
hefte  = 4		# Definition der Variable 'hefte'  und Wertzuweisung 4
stifte = 2		# Definition der Variable 'stifte' und Wertzuweisung 2
fuller = 1		# Definition der Variable 'fuller' und Wertzuweisung 1
```

Nach Zuweisung existieren die Variablen im Arbeitsspeicher, dem sogenannten \textit{Workspace}

Die Variablen können jetzt wie Zahlen in Berechnungen genutzt werden

```{r}
gesamt  = hefte + stifte + fuller                    # Berechnung der Gegenstandsanzahl
print(gesamt)
```


Ein Heft kostet einen Euro, ein Stift kostet zwei Euro, und ein Füller kostet 10 Euro. Wie viel Euro muss Greta insgesamt bezahlen?
```{r}
gesamtpreis	= hefte*1 + stifte*2 + fuller*10         # Berechung des Preises
print(gesamtpreis)
```

`print()` gibt Variablenwerte in der R Konsole aus.


# Variablen
\textcolor{darkblue}{Workspace}
\vspace{1mm}

\footnotesize

`ls()` zeigt die existierenden benutzbaren Variablen im Arbeitsspeicher an

```{r}
ls()						# Anzeigen aller Variablennamen im Workspace
```
\vspace{2mm}

`rm()` erlaubt das Löschen von Variablen

```{r}
rm(gesamtpreis)		        # Löschen der Variable Gesamtpreis
ls()
```
\vspace{2mm}

`rm(list=ls())` löscht alle Variablen
```{r}
rm(list = ls()) 	        # Löschen aller Variablen
ls()
```


# Variablen
\textcolor{darkblue}{Workspace}
\vfill
```{r, echo = FALSE, out.width = "90%"}
knitr::include_graphics("2_Abbildungen/pds_2_workspace.pdf")
```
\vfill



# Variablen
\setstretch{1.6}
\textcolor{darkblue}{Variablennamen}

\vspace{2mm}

Zulässige Variablennamen

... bestehen aus Buchstaben, Zahlen, Punkten (.) und Unterstrichen (\_)

... beginnen mit einem Buchstaben oder . nicht gefolgt von einer Zahl

... dürfen keine reserverd words wie \textcolor{blue}{for}, \textcolor{blue}{if}, \textcolor{blue}{NaN}, usw. sein ($>$?reserved)

... werden unter ?make.names() beschrieben


Sinnvolle Variablennamen

... sind kurz ($\approx$ 1 bis 7 Zeichen) und aussagekräftig

... bestehen nur aus Kleinbuchstaben und Unterstrichen


# Variablen
\textcolor{darkblue}{Variablenrepräsentation $\vert$ Binding}
\vspace{1mm}
\footnotesize
\setstretch{0.5}

```{r, eval = F}
x = 1
```

Intuitiv wird eine Variable genannt x mit dem Wert 1 erzeugt.

De-facto geschehen zwei Dinge:

1. R erzeugt ein Objekt (Vektor mit Wert 1) mit Speicheradresse `lobstr::obj_addr(x).
2. R verbindet dieses Objekt mit dem Namen x, der das Objekt im Speicher referenziert.


```{r, echo = FALSE, out.width="22%"}
knitr::include_graphics("2_Abbildungen/pds_2_binding_1.pdf")
```
\vspace{1mm}

```{r, eval = F}
y = x
```

Intuitiv wird eine Variable genannt y mit Wert gleich dem Wert von x erzeugt.

De-facto wird ein neuer Name y erzeugt, der dasselbe Objekt referenziert wie x:

```{r, echo = FALSE, out.width="22%"}
knitr::include_graphics("2_Abbildungen/pds_2_binding_2.pdf")
```
\vspace{1mm}

Man überzeuge sich mit `lobstr::obj_addr(x)` und `lobstr::obj_addr(y).

Das Objekt (Vektor mit Wert 1) wird nicht kopiert, R spart Arbeitsspeicher.


# Variablen
\textcolor{darkblue}{Variablenrepräsentation $\vert$ Copy-on-modify}
\vspace{2mm}
\small

```{r}
x = 1 		# Objekt (0x74b) erzeugt, x referenziert Speicheradresse  des Objektes
y = x		# y referenziert dieselbe Speicheradresse wie x (0x74b)
y = 3 		# y modifiziert, modifizierte Kopie (0xcd2) wird gespeichert
y        	# y referenziert jetzt (0xcd2)
```

```{r}
x           # x referenziert weiterhin (0x74b)
```


```{r, echo = FALSE, out.width="70%"}
knitr::include_graphics("2_Abbildungen/pds_2_copy_on_modify.pdf")
```

R Objekte sind \textit{immutable}, können also nicht verändert werden.


# Variablen
\textcolor{darkblue}{Variablenrepräsentation $\vert$ Copy-on-modify}
\vspace{2mm}
\small
\setstretch{2.5}

Zur Immutability gibt allerdings zwei Ausnahmen, genannt \textit{Modifications-in-place}

1. Objekte mit nur einem gebundenem Namen werden in-place modifiziert

    * \footnotesize Dieses Verhalten ist allerdings nur in R, nicht innerhalb RStudios reproduzierbar.

```{r, indent = "      "}
x = 1 		# Objekt (0x74b) erzeugt, x referenziert Speicheradresse des Objektes
x[1] = 2 	# Objekt (0x74b) veraendert
```

\small
2.  Environments werden in-place modifiziert ($\rightarrow$ Environments und Funktionen).

# Variablen
\textcolor{darkblue}{Variablenrepräsentation $\vert$ Unbinding und Carbage Collection}
\small

Copy-on-modify gilt auch in umgekehrter Reihenfolge

\footnotesize
```{r}
x = 1 		# Objekt (0x74b) erzeugt, x referenziert Speicheradresse  des Objektes
y = x		# y referenziert dieselbe Speicheradresse wie x (0x74b)
x = 3 		# Ein neues Objekt (0x2a08) wird erzeugt, x referenziert (0x2a08)
y           # y referenziert weiterhin  Objekt (0x74b)
```

```{r, echo = FALSE, out.width="56%"}
knitr::include_graphics("2_Abbildungen/pds_2_unbinding.pdf")
```
\vspace{-2mm}
\small
Unbinding
\footnotesize
```{r}
x = 1		#  x referenziert Objekt (0x74b)
x = "a"		#  x referenziert Objekt (0x2a08), Objekt (0x74b) jetzt ohne Referenz
```

\small
Carbage collection
\footnotesize

* Nicht referenzierte Objekte im Arbeitsspeicher werden automatisch gelöscht.
* Das Löschen geschieht meist erst dann, wenn es wirklich nötig ist.
* Es ist nicht nötig, aktiv die Garbage Collection Funktion `gc()` zu benutzen.

#
\large
\vfill
\setstretch{2.5}

R und RStudio

Arithmetik, Logik und Präzedenz

Variablen

**Datenstrukturen**

Übungen und Selbstkontrollfragen




# Datenstrukturen
\textcolor{darkblue}{Klassische Datenstrukturen einer 3GL Programmiersprache}

\small
\textcolor{darkblue}{Fundamentale Datenstrukturen}

* Vordefiniert innerhalb der Programmiersprache
* Logische Werte (logical): TRUE, FALSE
* Ganze Zahlen (integer): int8 (-128,...,127), int16 (–32768,..., 32767)
* Gleitkommazahlen (single, double): 1.23456, 12.3456, 123.456, ...
* Zeichen (character): "a", "b", "c", "!"
* Datentyp-spezifische assoziierte Operationen
    * \small AND, OR (logical) +, - (integer) +,-,*, / (single), Zeichenkonkatenation (character)

\textcolor{darkblue}{Zusammengesetzte Datenstrukturen}

* Vordefinierte Container zur Zusammenfassung mehrerer Variablen gleichen Datentyps
* Zum Beispiel Vektoren, Listen, Arrays, Matrizen, ...
* Container-spezifische Operationen (Z.B. Vektorindizierung, Matrixmultiplikation, ...)

\textcolor{darkblue}{Selbstdefinierte Datenstrukturen}

* Definition eigener Datenstrukturen aus vordefinierten Datenstrukturen und Containern
* Definition eigener Operationen


# Datenstrukturen
\textcolor{darkblue}{Datenstrukturenkennenlernen beim Erlernen einer Programmiersprache}

\small
\textcolor{darkblue}{Fundamentale Datenstrukturen}

* Welche fundamentalen Datenstrukturen bietet die Sprache an?
* Welche Operationen darauf sind bereits definiert?
* Wie lautet die Syntax zur Definition einer Variable eines fundamentalen Datentyps?
* Wie lautet die Syntax, um vordefinierte Operationen aufzurufen?

\textcolor{darkblue}{Zusammengesetzte Datenstrukturen}

* Welche Container und zugehörige Operationen bietet die Programmiersprache?
* Wie lautet die Syntax zum Umgang mit einem Containers?

\textcolor{darkblue}{Selbstdefinierte Datenstrukturen}

* Wie erzeugt man selbstdefinierte Datenstrukturen und zugehörige Operationen?
* Wie lautet die Syntax zum Umgang mit einer selbstdefinierten Datenstruktur?


# Datenstrukturen
\setstretch{1.8}
\textcolor{darkblue}{Organisation von Daten in R}
\vspace{1mm}

Alles, was in R vorkommt, ist ein **Objekt**
\vspace{1mm}

Jedem Objekt kann eindeutig zugeordnet werden

* ein **Modus**
    * Atomar  $\,\,\vert$ Komponenten sind vom gleichen Datentyp.
    * Rekursiv $\vert$ Komponenten können von unterschiedlichem Datentyp sein.

* eine **Länge**

* optional weitere **Attribute**

# Datenstrukturen
\setstretch{1.8}
\textcolor{darkblue}{Organisation von Daten in R}
\vspace{1mm}

Alles, was in R vorkommt, ist ein **Objekt**
\vspace{5mm}

```{r, echo = FALSE, out.width="80%"}
knitr::include_graphics("2_Abbildungen/pds_2_r_objektstruktur.pdf")
```



# Datenstrukturen
\textcolor{darkblue}{Übersicht der R Datentypen}
\small
\setstretch{1.8}
\vspace{5mm}
\begin{center}
\begin{tabular}{l|l}
Datentyp
& Erläuterung
\\\hline
logical
& Die beiden logischen Werte TRUE und FALSE
\\
double
&
Gleitkommazahlen
\\
integer
& Ganze Zahlen
\\
complex
& Komplexe Zahlen, hier nicht weiter besprochen
\\
character
& Zeichen und Zeichenketten (strings), 'x' oder ``Hallo Welt!''
\\
raw
& Bytes, hier nicht weiter besprochen
\\
\end{tabular}
\end{center}
\vspace{2mm}


Double und integer werden zusammen auch als numeric bezeichnet.

Viele weitere Typen, hier relevant sind **logical**, **double**, **integer**, **character**.


# Datenstrukturen
\setstretch{0.8}
\vspace{1mm}
\textcolor{darkblue}{Übersicht der R Datentypen}
\footnotesize

Automatische Festlegung von Datentypen durch Zuweisung
\vspace{1mm}

```{r}
b = TRUE					# logical
x = 2.5 					# double
y = 1L						# (long) integer
c = 'a' 					# character
```

Testen von Datentypen durch `typeof()`
\vspace{1mm}

```{r}
typeof(b)
```

```{r}
typeof(x)
```

```{r}
typeof(y)
```

```{r}
typeof(c)
```

Testen von Datetypen durch `is.*()`
\vspace{1mm}

```{r}
is.logical(x)
```

```{r}
is.double(x)
```

# Datenstrukturen
\setstretch{2.5}
\textcolor{darkblue}{Übersicht atomare Datenstrukturen in R}
\vspace{3mm}

\begin{center}
\begin{tabular}{l|l}
Datenstruktur
& Erläuterung
\\\hline

Vektor
& Container von indizierte Komponenten identischen Typs
\\

Matrix
& Interpretation eines Vektors als zweidimensionaler Container
\\

Array
&  Interpretation eines Vektors als mehrdimensionaler Container

\end{tabular}
\end{center}
\vspace{3mm}


$\Rightarrow$ (3) Vektoren, Matrizen, Arrays


# Datenstrukturen
\setstretch{2.5}
\textcolor{darkblue}{Übersicht rekursive Datenstrukturen in R}
\vspace{3mm}

\begin{center}
\begin{tabular}{l|l}
Datenstruktur
& Erläuterung
\\\hline

Liste
& Container von indizierten Komponenten beliebigen Datentyps
\\
& Insbesondere auch rekursive Struktur, z.B. Liste von Listen
\\

Dataframe
& Symbiose aus Liste und Matrix
\\
& Jede Komponente ist Vektor beliebigen Datentyps identischer Länge
\\
\end{tabular}
\end{center}
\vspace{3mm}
$\Rightarrow$ (4) Listen und Dataframes


#
\large
\vfill
\setstretch{2.5}

R und RStudio

Arithmetik, Logik und Präzedenz

Variablen

Datenstrukturen

**Übungen und Selbstkontrollfragen**


# Übungen und Selbstkontrollfragen
\footnotesize
\setstretch{1.6}

1. Installieren Sie R und RStudio auf Ihrem Rechner.
2. Führen Sie die Befehlssequenz auf Folie \textcolor{blue}{R Skripte $\vert$ Executing and Editing Code} aus.
3. Dokumentieren Sie die in dieser Einheit eingeführten R Befehle in einem kommentierten R Skript.
4. Erläutern Sie den Begriff der Operatorpräzedenz.
5. Definieren Sie den Begriff der Variable im Kontext der Programmierung.
6. Erläutern Sie die Begriffe Initialisierungsanweisung und Zuweisungsanweisung für Variablen.
7. Erläutern Sie den Begriff Workspace.
8. Geben Sie jeweils ein Beispiel für einen zulässigen und einen unzulässigen Variablennamen in R.
9. Erläutern Sie die Prozesse, die R im Rahmen einer Zuweisungsanweisung der Form x = 1 durchführt.
10. Erläutern Sie den Begriffe Copy-on-modify und Modify-in-place.
11. Diskutieren Sie die klassischen Datenstrukturen einer 3GL Programmiersprache.
12. Diskutieren Sie die Organisation von Datenstrukturen in R.
13. Wodurch unterscheiden sich eine atomare und ein rekursive Datenstruktur in R?
14. Nennen und erläutern Sie vier zentrale Datentypen in R.
15. Nennen und erläutern Sie vier zentrale atomare Datenstrukturen in R.
16. Nennen und erläutern Sie zwei zentrale rekursive Datenstrukturen in R.


# References
\footnotesize
