#####################
## Einführung in R ##
#####################

####################################
## Teil 0: Wie gehe ich mit R um? ##
####################################

?plot   
help(plot)           #Ruft Hilfe zu einzelnem Befehl auf
help.start()         #Startet Dokumentation zu R im Browser 
q()                  #Beendet R
# blablabla          #Kommentar


############################################
## Teil 1: Grundlegende Rechenoperationen ##
############################################


## .......... Grundrechenarten ...........##

1 + 2                #Summe 
2 - 1                #Differenz
2 * 3                #Produkt
4 / 2                #Quotient
1001 %% 11           #Modulo

## .....erweiterte Rechenoperationen .....##

sqrt(2)              #Wurzel (Möglichkeit 1)          
2 ^ (1/2)            #Wurzel (Möglichkeit 2)
exp(1)               #e-Funktion
log(2)               #natürlicher Logarithmus
sin(pi)		   #Sinus
cos(pi)		   #Kosinus
abs(-3)		   #Betrag
sign(-3)		   #Signum


## ............Zahlzuweisung..............##

x <- 4
x
x <- sqrt(36)        #weist die Zahl dem Objekt 'x' zu (überschreibt vorheriges Objekt)
x                    #gibt x aus (nicht in Skripten)
print(x)             #gibt x aus (auch in Skripten)


##........Vektoren und Matrizen...........##

X <- c(1,2,6,5,9)    #Vektoren durch einzelne Elemente definieren
Y <- rep(3,5)        #Vektor der fünfmal die drei enthält
Z <- seq(2,10,2)     #alle Zahlen von zwei bis zehn in 2er-Schritten
U <- 1:5             #entspricht seq(1,5,1)
V <- c(X, U, 6)	   #hängt die Vektoren X und U hintereinander und 6 als weiteres 
			   #Element dran
X+Y			   #elementweise Addition
X*Z			   #elementweise Multiplikation
X%*%Z                #Vektormultiplikation
sqrt(U)              #ebenfalls elementweise
length(U)            #gibt Länge aus
X[1]                 #Auswählen von Teilvektoren (Beginn bei 1! -> Unterschied zu z.B. Java)
X[3:5]		         # -||-
X[c(4,2,1)]          # -||-
W=c(TRUE, TRUE, FALSE, TRUE, FALSE)
X[W]			   # -||-

#Beispiele
# Gib alle Elemente von X, die größer als 5 sind aus
# Gib alle Elemente von X, die mindestens 2 sind und für die das 
		# entsprechende Element von Z höchtens 8 ist, aus 
X[X>5]               
X[X>=2 & Z<=8]       # -||-

A <- matrix(0,2,3)                      #2x3 Matrix mit lauter Nullen
A
A[1,3] <- 5                             #einzelnes Element zuweisen
A
A[,2] <- c(1,8)                         #eine ganze Spalte zuweisen
A
B <- matrix(c(1,1,1,1,4,5,6,7,9),3,3)   #Matrix anhand ihrer Werte definieren
B
C <- diag(c(5,7,-1.2))                  #Diagonalmatrix erstellen
C
x=c(1,1,1)
y=c(1,0,1)
z=rep(2,3)
cbind(x,y,z)				# Matrix durch ihre Spaltenvektoren definieren
rbind(x,y,z)				# Matrix durch ihre Zeilenvektoren definieren

B+C
A%*%B                                   #Matrixmultiplikation
sqrt(B)					    #auch auf Matrizen können Funktionen 
						    #elementweise angewandt werden	
A <- rbind(A, c(0,1,5))                 #Zeile hinzufügen
A

#es existieren viele weitere Funktionen für Vektoren und Matrizen


# Workspace im Überblick behalten

ls()
rm(x)                #löscht das Objekt 'x'
ls()
x                    #'x' nicht mehr vorhanden
rm(list=ls())	   # löscht alle Variablen im Workspace	


# Vergleiche
y=5
z=10
y<z
y<=z
y>z
y>=z
y==z			# Zum Vergleichen zwei Gleichheitszeichen; ein Gleichheitszeichen
			# ist Zuweisung
y!=z


## .............Data Frames............. ##

x <- c("Franz", "Anton", "Heinrich")            #Vektor aus Strings
y <- c(1.0, 1.7, 2.7)
z <- c(95, 85, 67)
Notenliste <- data.frame(Name=x, Note=y, Punkte=z)     #erstellt Data Frame
Notenliste
Notenliste <- rbind(Notenliste, data.frame(Name="Maria", Note=3.7, Punkte=54)) 
Notenliste												       #fügt Zeile hinzu

Geschlecht <- c(rep("m", 3), "w")               #erstellt neuen Vektor
                                                #rep: wiederholt 3 Mal "m", c: verbindet 2 Vektoren
Geschlecht                                      #Ausgabe

Notenliste <- cbind(Notenliste, Geschlecht)     #fügt Spalte hinzu
Notenliste
Notenliste$Note                                 #greift auf Spalte "Note" als Vektor zu
Notenliste$Punkte = NULL                        #löscht Spalte
Notenliste

Notenliste[2]                                   #VORSICHT! >> liefert Data Frame
Notenliste[[2]]                                 #greift auf die Spalte "Note" als Vektor zu
Notenliste[2,3]                                 #gibt 2. Zeile 3. Spalte aus
                                                #Alternativ Notenliste[[2,3]])
Notenliste <- Notenliste[c(1,3,4),]             #löscht 2. Zeile
subset(Notenliste, Geschlecht == "m")           #gibt Teil-Data Frame aus



## ......Schleifen und Bedingungen....... ##

for (i in 1:10) {
    print(c(i, i^2, i^3))         #gibt die jeweilige Zahl mit ihrer zweiten und
					    #dritten Potenz aus
}

# Beispiel: Berechne die Summe eines Vektors
v=c(27, 0, 15, -6, 8)

s=0
for(x in v){
s=s+x;
}
s;


if (2>1) {           #Bedingung
   print(2)          #Handlung bei Erfüllung
} else {             #ansonsten...
  print(1)           #Handlung bei Nichterfüllung
}





########################
## Teil 2: Funktionen ##
########################

# Vordefinierte Funktionen: sqrt(x), exp(x), log(x), sin(x), cos(x), ...

 # Gauss-Klammer (findet die größte ganze Zahl, die kleiner gleich x ist)
 gauss <- function(x) {
   k <- 0
   while (k <= x) {
     k <- k + 1
     }
   return (k - 1)
   }

gauss(4.0)
gauss(sqrt(50))
gauss(-pi)       ### Für x < -1 liefert unsere Implementierung falsche Werte!


# Verteilungen und Zufallsvariablen

dnorm(0)			#Dichte der Standardnormalverteilung an der Stelle 0
dnorm(0,2,1)		#Dichte der N(2,1)-Verteilung an der Stelle 0
dnorm(0, mean=2, sd=1)
dnorm(0, sd=1, mean=2)	#Vertauschen der Reihenfolge macht nichts

pnorm(-2:2)			#Verteilungsfunktion
qnorm(0.5, mean=2, sd=1)#Quantile
rnorm(1)			#Eine standardnormalverteilte Zufallsvariable
rnorm (10, mean=2, sd=1)#10 unabhängige N(2,1)-verteilte Zufallszahlen

# Genauso funktionieren 
rexp(10,3)				#Exponentialverteilt
runif(min=21, max=23, 10) 	#Gleichverteilt
rgamma(10, shape=5, rate=8)	#Gammaverteilt


#statistische Auswertung: mean(x), var(x), median(x), min(x), quantile(x,q)
x <- rexp(1000, 1.5) #simuliert 1000 Realisierungen der Exp(1.5)-Verteilung
mean(x)
var(x)
max(x)
quantile(x,0.1)

# Tests
#######
# Bsp.: Der t-Test aus Abschnitt 2.2
# Teste H_0: mu=mu_0 gegen H_1: mu ungleich mu_0 bei Normalverteilung 
# mit unbekannter Varianz 
x=rnorm(1000)
t.test(x)
t.test(x,mu=0.2,alternative="less")
t.test(x,conf.level=0.9)		# conf.level betrifft das Niveau des
						# Konfidenzintervals, das angezeigt wird.


 # Schiefe und Wölbung 
 #####################

 # Schiefe (Skewness): E((X - EX)^3) / (Var(X))^(3/2)
# Wölbung (Kurtosis): E((X - EX)^4) / (Var(X))^(4/2)
# Standard-Normalverteilung hat Schiefe 0 und Wölbung 3
 # Schiefe > 0: rechtsschief / linkssteil
# Schiefe < 0: linksschief / rechtssteil
 # Wölbung > 0: steilgipflig
 # Wölbung < 0: flachgipflig

# Paket moments laden
library(moments)

 # Schiefe und Wölbung berechnen
x <- rnorm(100, 0, 1)
 skewness(x)
 kurtosis(x)

 x <- rt(100, 2)
 skewness(x)
 kurtosis(x)

 # t-Verteilung nähert sich für wachsende Freiheitsgrade der Standardnormalverteilung an
 x <- rt(100, 20)
 skewness(x)
 kurtosis(x)





######################################
## Teil 3: Allgemeine Grafiken in R ##
######################################


 ## Scatterplot
 ##############

 x <- c(1, 2, 3, 4, 6)
 y <- c(4, 6, 5, 7, 6)
 # einzelne Punkte plotten
 plot(x, y)

 ## Parameter
 ############

 # erzeugt eine 2x2-Matrix von Bildern in einem Fenster (Bilder werden zeilenweise erzeugt)
 par(mfrow = c(2,2))

 # Beschriftung der x- und y-Achse
 plot(x, y, xlab = "x-Achse", ylab = "y-Achse")

 # Bereich der x- und y-Achse von Hand vorgeben, Plotsymbol
 plot(x, y, type = "p", xlim = c(1, 10), ylim = c(0,8), pch=16)

 # farbiger Plot / Linienstil / Linienstärke / Titel
 plot(x, y, col = "red", type = "l", lty = 2, lwd = 3, main = "Mein Plot")
# type="p" erzeugt Punkte (ist default)

 # Untertitel
 plot(x, y, type = "b", lty = 3, sub = "Unterschrift")


 ## Plotten eines data.frames

 ## Lade die Bibliothek MASS
 library(MASS)
 data(hills)
 summary(hills)
 help(hills)

 plot(hills$time,hills$climb)
 plot(hills$climb ~ hills$time)
 plot(climb~time, data=hills)
# Nicht zulässig:
plot(time,climb, data=hills)

 ## Balkendiagramme
 ##################
par(mfrow = c(1,1))

 # Standard-Balkendiagramm
 barplot(y)

 # horizontales Balkendiagramm
 barplot(y, horiz = TRUE)
 # es gibt viele Parameter, siehe ?barplot


## zusätzliche Elemente in ein vorhandenes Diagramm einfügen)

 #################

 # zuerst normalen Plot erzeugen
 plot(x, y)

 # zusätzliche Geraden einzeichnen
 abline(3, 0.75, col = "red", lwd = 3)

 # horizontale Geraden (vgl. auch abline(v = 3))
 abline(h = 5, col = "blue", lwd = 3)

 # Titel angeben
 title("Ueberschrift")

 # Liniensegment einzeichnen
 segments(2, 5.5, 4, 6.5, col = "green", lwd = 3)

# Einen Streckenzug
 lines(c(1,2,3),c(6,6.5,-1), col="brown")

# Weitere Punkte
points(c(3,5), c(4.5,4.5), pch=16)

 # Legende angeben (Position, Inhalt)
 legend(x = 4, y = 4.5, legend = c("m", "w"), lty = c(1, 2), col = c("brown", "black"),
          lwd = c(3, 1))


# Achsen bearbeiten
data(Animals)
Animals
plot(Animals)
# Datenpunkte in linker untere Ecke zusammengedrängt
# Lösung: Daten logarithmieren
plot(log(Animals))
# Achse passen nicht mehr
plot(log(Animals),axes=F) # erzeugt Plot ohne Achsen und Umrandung
box()
axis(1, at=c(0,log(100),log(10000)), labels=c(1,100,10000))
axis(2, at=c(0,log(10),log(100),log(1000)), labels=c(1,10,100,1000))

#Text
text(x=log(Animals$body), y=log(Animals$brain), label=row.names(Animals),pos=4)
# pos=4: rechts neben Datenpunkt



 ################################
 ## Teil 4: Funktionen plotten ##
 ################################

 # function(x) sagt, dass das was danach kommt (ohne Komma dazwischen) eine Funktion in x ist
 # zusätzlich die Dichte plotten mit add = TRUE (funktioniert auch bei plot(function(x)
...))

plot(function(x) sin(x),-6,6)        #plottet Sinusfunktion in [-6,6]
curve(sin, xlim=c(-6,6))
curve(sin(x), xlim=c(-6,6))


 ## Beispiel: Verteilungsfunktion der N(2,9)-Verteilung
 ######################################################

plot(function(x) pnorm(x, mean = 2, sd = 3), -8, 12)
curve(dnorm(x, mean = 2, sd = 3), -8, 12, col = "red", add = TRUE)
curve(exp, col="blue", add=TRUE)


 ## eigene Funktionen plotten (Achtung: Funktion muss Vektoren verarbeiten können!)
 ############################

 # Gauss-Klammer (findet die größte ganze Zahl, die kleiner gleich x ist)
 gauss <- function(x) {
   k <- 0
   while (k <= x) {
     k <- k + 1
     }
   return (k - 1)
   }

 # Fehler! Die Funktion gauss(x) kann keine Vektoren verarbeiten.
 curve( gauss, xlim=c(1, 5.5))

 # Gauss-Klammer die mit Vektoren zurechtkommt
 gauss2 <- function(x) {
 # Rückgabewert soll ein Vektor mit der gleichen Länge wie x sein

 k <- rep(0, length(x))
 # Schleife über alle Elemente von x
   for (i in 1:length(x)) {
     while (k[i] <= x[i]) {
       # überall den Index i hinzufügen
       k[i] <- k[i] + 1
       }
     }
  # den Vektor k - 1 zurückgeben
   return (k - 1)
 }

 curve( gauss2, xlim=c(1, 5.5)) # klappt
curve(gauss2(x^2),col="red",add=T)
# Alternative: Funktion mit lines einzeichnen
# Wir zeichnen    sin(x)+2   auf den Intervall [3.0,4.5]
lines(((30:45)/10), sin((30:45)/10)+2)


## Dreidimensionale Plots
 #########################

 # Vektor der x-Werte
 x <- seq(0, 1, 0.1)

 # Vektor der y-Werte
 y <- seq(0, 1, 0.1)

 # einfache Funktion zur Berechnung der z-Werte
 f <- function(x, y) {
   return (x^2 * y)
   }

 z <- outer(x, y, f)
 # Schema zur Berechnung von z:
 # x/y | 1 | 2 | 3
 # 1 | f(1,1) | f(1,2) | f(1,3)
 # 2 | f(2,1) | f(2,2) | f(2,3)

 # perspektivischer Plot, Blickwinkel als Parameter
 # theta = Azimut (Drehung in x/y-Ebene), phi = Kobreite = 90° - Breite (Kippen nach oben))
 persp(x, y, z, theta = 30, phi = 15)

 # Konturlinien, Anzahl / Dichte der Linien als Parameter
 contour(x, y, z, nlevels = 15)

 # Bild, d.h. z wird als Höhe interpretiert
 image(x, y, z)

 # Farbschema als Parameter angeben
 par(mfrow=c(2,4))
 image(x, y, z, col=heat.colors(5))
 image(x, y, z, col=topo.colors(5))
 image(x, y, z, col=terrain.colors(5))
 image(x, y, z, col=rainbow(5))
 image(x, y, z, col=heat.colors(5000))
 image(x, y, z, col=topo.colors(5000))
 image(x, y, z, col=terrain.colors(5000))
 image(x, y, z, col=rainbow(5000))



 ################################
 ## Teil 5: Statistische Plots ##
 ################################

 ## Histogramme
 ##############

par(mfrow=c(1,1))

 # Erzeugen von 1000 standardnormalverteilten Pseudozufallszahlen
 x <- rnorm(1000, 0, 1)

 # freq = FALSE plottet relative Häufigkeiten
 hist(x, freq = FALSE)


 ## Boxplot
 ##########

# erzeuge drei Gruppen von Werten
 x1 <- c(rnorm(100, 0, 1), 4)
 x2 <- c(rnorm(100, 2, 1), -1)
 x3 <- c(rnorm(100, 1, 1), 5)

boxplot(x1)

 # Dataframe erzeugen
 x <- data.frame(x1, x2, x3)

 # Boxplot
 boxplot(x)

 # kein Plot, nur Statistiken ausgeben
 boxplot(x, plot = FALSE)$out

 ## QQ-Plot
 ##########

 # Stichprobe x1 vs. Standardnormalverteilung
 qqnorm(x1)

# zusätzliche Linie durch 1. und 3. Quartil zeichnen

 qqline(x1)

 z1 <- rexp(100, 2)
 z2 <- rgamma(300, 4, 5)

 # QQ-Plot mit zwei Stichproben
 qqplot(z1, z2)
abline(0,1)



################################
## Teil 6: Arbeit mit Dateien ##
################################

##........Speichern und Lesen............##

getwd()                                 #aktuelles Arbeitsverzeichnis anzeigen
setwd("C:/Users/kampfjue/documents/Lehre_R/") 
			                      #Arbeitsverzeichnis festlegen
# Alternative: im Menü: Datei - Verzeichnis wechseln

write(rpois(25,2),file="data.txt")      #schreibt Daten in Datei
x<-scan("data.txt")                     #liest Datei wieder ein 
print(x)                                #Ausgabe

pdf(file="plot_Normalvert.pdf"          #erstellt Datei für Plot
plot(function(x) dnorm(x,0,1),-3,3)     #zeichnet
dev.off()                               #schreibt erst jetzt(!) in Datei


Alternative:
 # Plot erzeugen
plot(function(x) dnorm(x,0,1),-3,3)

 # Verzeichnis angeben
 dev.print(postscript, "plot_Normalvert.ps")

# Speichern und Lesen von Data frames: Fortsetung des obigen Beispiels
write.table(Notenliste, file="Notenliste.txt", quote=F, row.names=F)           
												#schreibt Data Frame in Datei
                                                #quote=F: lässt Anführungszeichen weg
                                                #row.names=F: lässt Spaltennummer weg
write.table(Notenliste, file="../Notenliste.txt",sep=";")
						#sep=";": Die Spalten werden durch ein Semikolon getrennt.
rm(Notenliste)
Notenliste <- read.table("Notenliste.txt", header=T) 
								#liest Datei ein und erstellt Data Frame