• Skripte schreiben (ca. 15 Minuten)

• Bausteine für Skripte (ca. 30 Minuten)

• Funktionen schreiben (ca. 15 Minuten)

• Vektorisierung in R (ca. 15 Minuten)

• Daten importieren (ca. 15 Minuten)

• Daten speichern und exportieren (ca. 15 Minuten)

• Plots in R erzeugen (ca. 45 Minuten)

• R-Skripte enthalten alle Arbeitsschritte, die im Laufe eines Projekts anfallen und durch R abgearbeitet werden.
• Skripte sind fundamentale Grundlage aller Analysen.
• Skripte enthalten die Abfolgen von Funktionen und Kommentaren.
• Skripte müssen verständlich und reproduzierbar sein.

• Kommentare, Kommentare, Kommentare!!!
• Von Prosa (horizontal) hin zu Lyrik (vertikal).
• Nicht Zeit sparen, um zu Schreiben, sondern um Verstehen zu können.
• Schreiben mit Passion aber auch Gelassenheit.
• An die anderen denken, nicht nur an sich selbst, nicht nur für den Moment.
• Es gibt so viele verschiedene Wege zur (gleichen) Lösung…

Generell: Es gibt Style-Guides fast wie Sand am Meer. Wichtig ist:

• Für sich selbst konsistent zu bleiben
• Für andere lesbar zu sein

Einige Beispiele:

• Hadley Wickhams Advanced R Style Guide: http://adv-r.had.co.nz/Style.html
• Der Google Style Guide: https://google.github.io/styleguide/Rguide.xml
• Bioconductor Style Information: https://www.bioconductor.org/developers/how-to/coding-style/

• Skripte werden mit der Dateiendung .R gespeichert.
• Skripte können in RStudio blockweise (Strg + Enter in der entsprechenden Zeile), abschnittsweise (Markieren und dann Strg + Enter) oder komplett ausgeführt werden (Shift + Strg + Enter).
• Gespeicherte Skripte können auch ohne geladen zu sein ausgeführt werden: source()

source(file = "~/Documents/projects/Environmental_seismology/Bergholz_Rehbruecke/R/calculus_and_figures.R")

• Kopfteil – Die Kurzzusammenfassung des Arbeitsplans
  • Grund/Ziel des Skripts
  • Autorinformation (Name, Institution, ggf. Adresse)
  • Datum und Version des Skripts
  • Dokumentation von Veränderungen (wann, wo, wie, warum)
  • Verwendete Parameter/Argumente (Name, Verwendung)
  • Ausgaben des Skripts (Daten, Plots, Dateien etc.)
  • Referenzen/Quellenangaben

• Objektnamen (Variablen und Funktionen)
  • Selbsterklärend
  • Balance zwischen zu lang und zu kurz finden
  • Konsistente Verwendung von Trennzeichen (parTime, par_time, par.time)
  • Keine Doppelbelegungen, auch nicht mit Funktionen (t, c, usw.)

• Verwendung des assign-Operators (<-), um Werte zuzuweisen (x <- 1)

• Verwendung von =, um Funktionsargumente zu definieren (mean(x = 1:10))

• Setzen von Klammern um Argumente/Operatoren und nach Kommas (1 + 1, cor(x = 1:10, y = 10:1))

• Nie mehr als 80 Zeichen pro Zeile

• Einrücken erleichtert Lesbarkeit (Schleifeninhalte 2 Leerzeichen):

if(i < 10) {
  i <- i + 1
} else {
  print("FINISHED!")
}

## versus

if(i < 10){i <- i + 1}else{print("FINISHED!")}

Oder auch:

L <- list(x = c(1, 2, 3, 4, 5, 6, 7), b = rep(1:10), t = as.logical(5 < 1:10))

## versus

L <- list(x = c(1, 2, 3, 4, 5, 6, 7), 
          b = rep(1:10), 
          t = as.logical(5 < 1:10))

• Ausschreiben der Funktionsargumente
  • Erleichtert die Verständlichkeit
  • Hilft beim Lernen der Sprache R
  • Strukturiert den Skript-Code

x <- runif(100, 0, 1)

## versus

x <- runif(n = 100, 
           min = 0, 
           max = 1)

• Kommentare sind eminent wichtige, integrale Bestandteile von Skripten
• Faustregel: Code ca. 60 %, Kommentare ca. 40 %

• Also, kommentieren schadet nie. Es hilft beim Schreiben wie auch beim Nachvollziehen.

• Kommentare werden eingeleitet mit einer oder mehr Rauten #, ##

• Sections (Abschnitte) strukturieren das Skript und RStudio nutzt sie als Sprungmarken/Lesezeichen.

## TEIL 1 - Datenimport -------------------------------------------------------

• Zeit: 10 Minuten, Art: selbständige Arbeit
  • Überlegen Sie sich ein Beispielprojekt (z.B. Deskriptive Statistik einer Datenreihe erstellen)
  • Starten Sie RStudio, legen Sie eine neues Projekt an
  • Schreiben Sie ein Skript für das Beispielprojekt
  • Beachten Sie (möglichst) alle gerade diskutierten Regeln
  • Am Ende Diskussion der Ergebnisse

• Alle Arbeiten finden in einem Arbeitsverzeichnis (working directory) statt.
• Standardort für die Suche nach Dateien

• Ablageort für exportierte Daten

• Das Arbeitsverzeichnis wird zu Beginn festgelegt mit setwd() und kann angezeigt werden mit getwd().

setwd(dir = "~/Documents/projects/project_xy") # Linux
setwd(dir = "C:/data/projects/project_xy") # Windows
getwd()

## [1] "/home/mdietze/Documents/conferences/2016/R-Kurs_KBV/R"

• Packages enthalten zusätzliche Funktionen, zur Zeit fast 10.000 Packages auf dem CRAN (Comprehensive R Archive Network) verfügbar
• Packages müssen einmalig installiert werden, Updates über RStudio Menü Tools

install.packages("EMMAgeo")

• Packages müssen aus der Bibliothek geladen werden

library("EMMAgeo")

• Alternativ kann Funktion auch nur mit Packagereferenz genutzt werden

EMMAgeo::EMMA()

• (Wiederholung vom Vortag)
• Konvertierung von Datentypen ist in absteigender Hierarchie problemlos, in aufsteigender Hierarchie mit Informationsverlust verbunden

• logical > integer > double > complex > character

• Konvertierung über as.TYPE(), z.B. as.numeric(), as.character

• Ein weites, buckeliges, mitunter mühsames Feld
• Nötig, da Funktionen manchmal nur bestimmte Datenstrukturen akzeptieren und wieder andere produzieren.
• Keine sinnvolle Übersicht erhältlich. Ein Anfang: http://micha-dietze.de/pages/r_cookbook.html#converting_data_structures

• Matrix zeilenweise in Vektor: as.numeric(X)
• Matrix spaltenweise in Vektor: as.numeric(t(X))

• einzelne Matrix-Spalten in Vektor: X[,1]

• Vektor in Matrix: rbind(x) oder cbind(x)

• Nota bene, statt as.numeric() können auch andere Typen erzeugt werden.

• Gesamte Liste (oder Data frame) in Vektor: unlist(L)

• Listen- (oder Data frame-)Element in Vektor: as.numric(L[[1]])

• Vektor in Liste: list(x)

• Vektor elementweise in Liste: as.list(x)

• Liste zeilenweise in Matrix: do.call(rbind, L)

• Liste spaltenweise in Matrix: do.call(cbind, L)

• Matrix zeilenweise in Liste: as.list(as.data.frame(t(X)))

• Matrix spaltenweise in Liste: as.list(as.data.frame(X))

• Eng verwandt mit Indizieren von Objekten (remember the two quotes…)
• Funktionen erzeugen neue Objekte einer bestimmten Struktur. Meist ist nur ein Teil davon nötig zum Weiterrechnen.
• Ein Beispiel: Autokorrelationsfunktion New York airquality

data("airquality") # load example data set
x <- acf(x = airquality$Wind) # autocorrelation function of wind data

Der Funktionsoutput sieht folgendermaßen aus:

## show structure of function output
str(x)

## List of 6
##  $ acf   : num [1:22, 1, 1] 1 0.3103 0.1633 0.211 0.0208 ...
##  $ type  : chr "correlation"
##  $ n.used: int 153
##  $ lag   : num [1:22, 1, 1] 0 1 2 3 4 5 6 7 8 9 ...
##  $ series: chr "airquality$Wind"
##  $ snames: NULL
##  - attr(*, "class")= chr "acf"

Zum Weiterrechnen sei nur Korrelationskoeffizient und lag nötig, dann:

k <- x$acf
lag <- x$lag

Diese Objekte können nun für weitere Analysen oder Plots genutzt werden:

plot(x = lag, y = k, type = "l")

• Es gibt ganze Bücher nur über dieses Thema: http://gastonsanchez.com/Handling_and_Processing_Strings_in_R.pdf
• Wichtig für die Datenaufbereitung, Analyse und auch Ausgabe
• Drei Gruppen
  • Mustersuche (pattern matching) und deskriptive Analyse
  • Austausch und Extraktion
  • Trennung und Zusammenführung

• Anzahl an Buchstaben: nchar()
• Pattern matching, indiziert: grep(pattern, x, perl, fixed, ...)
• Pattern matching, logisch: grepl(pattern, x, perl, fixed, ...)

x <- c("Ich", "bin", "ein", "Berliner", "!")
nchar(x)

## [1] 3 3 3 8 1

grep(x = x, pattern = "e")

## [1] 3 4

grepl(x = x, pattern = "e")

## [1] FALSE FALSE  TRUE  TRUE FALSE

• Austausch von String-Elementen gsub(pattern, replacement, x, ...)
• sub() verändert nur den ersten von mehreren Treffern
• Extraktion von String-Elementen mit substring(text, first, last)

x <- c("Ich", "bin", "ein", "Berliner", "!")
sub(x = x[4], pattern = "e", replacement = "E")

## [1] "BErliner"

gsub(x = x[4], pattern = "e", replacement = "E")

## [1] "BErlinEr"

substring(text = x[4], first = 1, last = 6)

## [1] "Berlin"

• Trennen von Texten mit strsplit(x, split, fixed, ...)
• Achtung, Funktionswert ist eine Liste (siehe lapply-Teil)

x <- c("a_short_string", "and_a_longer_one")
x_split <- strsplit(x = x, split = "_")
str(x_split)

## List of 2
##  $ : chr [1:3] "a" "short" "string"
##  $ : chr [1:4] "and" "a" "longer" "one"

print(x_split)

## [[1]]
## [1] "a"      "short"  "string"
## 
## [[2]]
## [1] "and"    "a"      "longer" "one"

• Zusammenfügen von Texten mit paste(sep, collapse, ...)
• Achtung, wenn nicht explizit angegeben, ist sep = " "
• Alternative paste0()

paste(x_split[[1]], collapse = "_")

## [1] "a_short_string"

paste("Die Summe von 1:10 ist ", sum(1:10), ".", sep = "")

## [1] "Die Summe von 1:10 ist 55."

• Schleifen sind wiederholte Durchläufe von Operationen
• Schleifen können endlos werden, wenn schlecht geschrieben
• R ist vektor-basiert, guter Code versucht, Schleifen zu minimieren
• Dennoch, Schleifen sind intuitiv und älter als Computersysteme
• Drei Typen von Schleifen:
  • for-Schleifen (vorweg definierte Anzahl an Durchläufen)
  • while-Schleifen (dynamische Anpassung der Durchläufe)
  • repeat-Schleifen (dynamische Anpassung der Durchläufe)

• Genereller Aufbau (Schleife wird anhand eines Zähl-Index durchlaufen):

for(i in a:b) {
  
  # do something based on i
}

• i ist der Zählindex, a und b die untere und obere Grenze
• mit jedem Durchlauf wird i um 1 erhöht

• Gute Praxis: vorweg Ergebnisobjekt definieren und i-weise indizieren

x <- 1:10

y <- numeric(length = length(x))

for(i in 1:length(y)) {
  
  y[i] <- sum(x[1:i])
}

y

##  [1]  1  3  6 10 15 21 28 36 45 55

• Genereller Aufbau (Schleife wird durchlaufen solange eine Bedingung erfüllt ist):

while(i < 10) {
  
  # do something that affects i
}

• i ist die Variable, die die Bedingung (condition) definiert
• mit jedem Durchlauf sollte i verändert werden

• Genereller Aufbau (Schleife wird durchlaufen bis Abbruch-Bedingung erfüllt):

repeat {
  
  # do something until break-condition is true
}

• es gibt keine Zählindices. In der Schleife wird mit break abgebrochen.

x <- 1
repeat {
  
  print(x)
  x <- x + 1
  if(x >= 3) break
}

## [1] 1
## [1] 2

• Gibt es Fragen oder Ideen zur Diskussion der letzten Reihe von Folien?
• Welche Bausteine fehlen oder sind zu kurz gekommen?

• Essentiell für kontinuierliches Arbeiten mit Daten in R
• Eine der Kernstärken von R, um die Funktionalität zu erweitern
• Eine Funktion ist eine Vorschrift, wie Daten zu bearbeiten sind

• Also, eine Abfolge von Ausdrücken, die Objekte erzeugen

• Folgt der allgemeinen Gleichungsdefinition in der Mathematik
  • f(x) = 3 · x
  • f <- function(x) {3 * x}

Funktionsname <- function(Argument_1, Argument_2, ...) {
  
  ## Tests
  if(is.numeric(Argument_1) == FALSE) {
    
    stop("Argument_1 ist nicht numerisch!")
  }
  
  ## Argumentmanipulationen
  Wert <- Argument_1 * Argument_2
  
  Wert <- ifelse(test = Wert > 0, 
                 yes = Wert, 
                 no = NA)
  
  ## Ausgabe des Funktionswertes
  return(Wert)
}

• Hilfsfunktionen finden häufig Anwendung in apply-Ausdrücken
• kurze Funktionen können ohne geschweifte Klammern definiert werden

x <- apply(X = X, 
           MARGIN = 1, 
           FUN = function(x) x^2)

• Funktionen können auch ohne Argumente definiert werden

ping <- function() {
  
  print("PING!")
}

• Funktionen müssen (ähnlich wie Packages) einmalig geladen werden
• Dazu muss ihre Definition ausgeführt werden (z.B. source())

• Danach stehen Sie im Environment-Fenster zur Verfügung

• Nun können Funktionen aufgerufen werden wie andere R-Funktionen:

ping()

## [1] "PING!"

Funktionsname(Argument_1 = -1, Argument_2 = 2)

## [1] NA

• Übergang kann nicht scharf definiert werden
• Skripte sollten kurz und selbsterklärend sein und i.W. Funktionen aufrufen
• Funktionen sollten aus Packages stammen oder selbst in einem (externen) Skript definert sein
• Analyseskripte können prinzipiell auch in Funktionen umgewandelt werden.

• Dinge, die wir leider hier nicht behandeln können:
  • Lokale vs. globale Variablen
  • Good practice (Tests der Argumente, Informationen ausgeben, Ausdrücke kommentieren)
  • Optionale und obligatorische Argumente
  • Vordefinierte Argumente
  • Das …-Argument

Daher: https://cran.r-project.org/doc/contrib/Lam-IntroductionToR_LHL.pdf

• R ist nicht entwickelt, um Schleifen effizient zu durchlaufen

• R ist entwickelt, um Vektoren effizient zu verarbeiten

• Daher gibt es Ansätze/Funktionen, die Arbeitsschritte "vektorisieren"

• Einfaches Beispiel: x <- 1:1000

x <- x * 10 vs. for(i in 1:1000) {x[i] = x[i] * 10}

• Schleifen vs. Vektorisierung spielt für kleine Datenmengen kaum eine Rolle
• Vektorisierter Code ist jedoch oft ausdrucksstärker als Schleifen

• Vektorielle Manipulation von Matrizen
• Berechnung zeilenweise (MARGIN = 1) order spaltenweise (MARGIN = 2)

• Keine echte Vektorisierung aber dennoch konsistent zu anderen apply-Typen

• Genereller Aufbau:

Y <- apply(X = X, MARGIN = 1, FUN = anyfunctionyoulike, additionalarguments)

Beispiele:

apply(X = X, MARGIN = 1, FUN = mean) # zeilenweise Mittelwertbildung
apply(X = X, MARGIN = 2, FUN = sd, na.rm = TRUE) # spaltenweise Standardabweichung
apply(X = X, MARGIN = 1, FUN = quantile, probs = 0.95) # zeilenweise Quantile

• Was wenn es keine Funktion gibt, die gebraucht wird?
• apply() erlaubt auch die Definition eigener Funktionen

f <- function(x) {sum(x)}

Y <- apply(X = X, MARGIN = 1, FUN = f)

Oder:

Y <- apply(X = X, MARGIN = 1, FUN = function(x) {sum(x)})

X <- matrix(data = 1:30, nrow = 3)

apply(X = X, MARGIN = 2, FUN = sum)

##  [1]  6 15 24 33 42 51 60 69 78 87

colSums(X)

##  [1]  6 15 24 33 42 51 60 69 78 87

apply(X = X, MARGIN = 2, FUN = function(x) {
  
  (x - min(x)) / (max(x) - min(x))
})

##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
## [1,]  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0   0.0
## [2,]  0.5  0.5  0.5  0.5  0.5  0.5  0.5  0.5  0.5   0.5
## [3,]  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0   1.0

• Analog zu apply() aber ohne Angabe von MARGIN, weil
• generell spaltenweise (vektorweise) Abarbeitung

• Echte Vektorisierung der Arbeitsschritte

• Genereller Aufbau:

Y <- lapply(X = L, FUN = anyfunctionyoulike, additionalarguments)

L <- list(a = 1:10, b = 11:20)

lapply(X = L, FUN = sum)

## $a
## [1] 55
## 
## $b
## [1] 155

lapply(X = L, FUN = function(x) {
  
  (x - min(x)) / (max(x) - min(x))
})

## $a
##  [1] 0.0000000 0.1111111 0.2222222 0.3333333 0.4444444 0.5555556 0.6666667
##  [8] 0.7777778 0.8888889 1.0000000
## 
## $b
##  [1] 0.0000000 0.1111111 0.2222222 0.3333333 0.4444444 0.5555556 0.6666667
##  [8] 0.7777778 0.8888889 1.0000000

• Import von ASCII-Dateien mit read.table() (tabellarische Daten) und readLines() ungegliederte Daten), Resultat ist ein Data frame
• Wichtige Argumente
  • file Dateiname
  • header (TRUE / FALSE) Kopfzeile mit Variablennamen
  • sep Spaltentrennzeichen (z.B. ;, \t)
  • na.strings NA-Belegung (z.B. NA, NULL, -9999)
• Achtung: stringsAsFactors (fast) immer manuell auf FALSE setzen!

• Excel-Dateien können mithilfe diverser Packages importiert werden
• Sinnvollstes Package ist xlsx (Installation mit install.packages("xlsx"))
• Package xlsx kann sehr viel mehr als Daten importieren (siehe Hilfe)!
• Funktion xlsx::read.xlsx() importiert einzelne Datenblätter in Data frames
• Weil Ziel ein Data frame ist, bitte die xls-Dateien so simpel wie möglich halten!

• Wichtige Argumente
  • file Dateiname
  • sheetIndex oder sheetName Index oder Name des Tabellenblattes
  • startRow und endRow zu importierendes Intervall
  • header Kopfzeile mit Variablennamen

• R unterstützt auch den Import von binären Daten
• Voraussetzung ist, dass die Struktur der binären Daten bekannt ist
• Schreiben von binären Importfunktionen setzt tieferes Wissen voraus
• Funktion: readBin()

• R besitzt ein eigenes, sehr effizientes Datenformat (.rda oder .RData)
• In diesem Format können beliebig viele Objekte zusammen gespeichert werden
• Speichern über Funktion save()

save(X, x, time, raw_data, file = "~/projects/R/data/case_01.rda")

• Datensammlung kann wieder geladen werden:

load(file = "~/projects/R/data/case_01.rda")

• Export von Matrizen oder Data frames über write.table()
• Andere Datenstrukturen (i.e., Listen oder S4-Objekte) müssen konvertiert werden
• Wichtige Argumente:
  • x R-Objekt, das exportiert werden soll
  • file Dateiname der Zieldatei
  • sep Spaltentrennzeichen
  • row.names und col.names Zeilen- und Spaltennamen mit exportieren

• Data frames (und auch Matrizen) können in bestehende Excel-Tabellen geschrieben werden
• Funktion: xlsx::write.xlsx()
• Wichtige Argumente:
  • x R-Objekt, das exportiert werden soll
  • file Dateiname der Zieldatei
  • sheetName Arbeitsblattname
  • row.names und col.names Zeilen- und Spaltennamen mit exportieren

• Die Erstellung von Plots in R is fundamental anders als z.B. in MS Excel
  • Definition was wie dargestellt wird, wird vorweg definiert
  • Einmal erzeugte Plots sind (fast) nicht mehr veränderbar
  • Sämtliche Ploteinstellungen erfolgen über Funktionsargumente
• Dieser Ansatz wird anfangs (z.T. zu Recht) als unlogisch und lästig empfunden
• Aber, im Grunde ist er elegant, nachvollziehbar/reproduzierbar und effektiv

plot(x = mtcars$hp, y = mtcars$mpg)

plot(x = 1:100, y = rnorm(n = 100), type = "l")

par(mfcol = c(1, 2), mar = c(5, 3, 3, 1))
plot(x = 1:20, y = rnorm(n = 20), type = "b")
plot(x = 1:20, y = rnorm(n = 20), type = "s")

pie(x = c(10, 60, 30))

X <- matrix(data = runif(n = 6), nrow = 2)
par(mfcol = c(1, 2), mar = c(5, 3, 0, 1))
barplot(X, col = c("orange", "darkblue"), beside = TRUE)
barplot(X, col = 3:4, horiz = TRUE)

par(mfcol = c(1, 2), mar = c(5, 3, 2, 1))
hist(rnorm(1000))
boxplot(x = list(a = rnorm(500), b = rnorm(500) + 1))

http://www.r-graph-gallery.com/ (Endlich wieder online!)

• Wichtige Plotelemente lassen sich als Argument angeben
  • Plottitel main
  • Achsen-Labels xlab und ylab
  • Achsen-Limits xlim und ylim
  • Plotsymbol pch
  • Elementgröße cex
  • Farbe(n) col
  • Logarithmische Skalierung log = "x", log = "xy"

• Weitere Anpassungen erfolgen über Plotparameteränderungen
• Anzeige und Veränderung aller Parameter und deren derzeitiger Werte mit par()
• Erklärungen der Fülle an Parametern siehe Hilfe: ?par

par(mar = c(3, 3, 1, 1)) # Anpassung des Plotrands
par(col.axis = "red", col.lab = "red", col.main = "red") # Labelfarben anpassen
par(font.axis = "Times", font.main = "Arial") # Schriftart anpassen
par(lty = 2, lwd = 2.5) # Linientyp und Stärke anpassen (geht auch direkt im Plot)
par(mfcol = c(1, 2)) # Mehrspaltige Plot-Flächen erzeugen

• Erzeugen eines leeren Plots (plot(NA, xlim = c(0, 1), ylim = c(0, 1), ann = FALSE, axes = FALSE))
• Hinzufügen von Achsen (axis(side = 1) und Rahmen (box())
• Hinzufügen von Titel (title()) und Achsen-Labels (mtext(side = 1, text = "lab"))
• Hinzufügen von Datenpunkten (points()), Linien (lines), Polygonen (polygon), Pfeilen (arrows)
• Hinzufügen einer Legende (legend())

• Plots können (und sollten) als Vektor- oder Rastergrafiken gespeichert werden
• Die Exportfunktion von RStudio ist nur begrenzt wertvoll

• Screenshots und Copy-Paste-Lösungen sind ein "Armutszeugnis"

• R besitzt mehrere sog. plot devices (Plotausgaben)
• Genereller Ablauf ist:
  • Plot device öffnen (leere Datei anlegen)
  • Plot erzeugen
  • Plot device schließen (Datei speichern)

• PDF-Dateien erzeugen, sinnvoll bei Vektorgrafiken

pdf(file = "~/R/plots/plot_01.pdf", width = 5, height = 4) # device öffnen

hist(rnorm(1000)) # Plot erzeugen

dev.off() # device schließen

• JPEG-Dateien erzeugen, sinnvoll bei Rastergrafiken

jpeg(filename = "~/R/plots/plot_02.jpg", width = 2000, height = 1500, res = 300) # device öffnen

hist(rnorm(1000)) # Plot erzeugen

dev.off() # device schließen

Das Schließen des Plot devices ist essentiell, um wieder auf dem Bildschirm Plots zu sehen!

• Beschaffen Sie einen eigenen Datensatz, mit dem wir morgen arbeiten
• Erstellen Sie ein neues Projekt mit passendem Namen
• Importieren Sie den Datensatz in R
• Bereiten Sie den Datensatz ggf. auf (Verändern der Struktur, Vergabe von Namen)
• Speichern Sie alle nötigen/sinnvollen Objekte

• Speichern Sie das Import/Aufbereitungsskript

• Überlegen Sie sich mögliche Analyse-Methoden für Ihren Datensatz

• Daten analysieren
  • Allgemeine deskriptive Statistik
  • Verteilungen von Daten testen
• Daten modellieren
  • Regressionsanalysen
  • Lineare und nichtlineare Modelle
• Schnittstellen zwischen R und anderer Software