Kapitel 3. Programmieren in R. Vorlesung Programmieren in statistischer Software: R Sommersemester Bedingte Anweisungen, Schleifen, Funktionen

Transkript

1 Vorlesung Programmieren in statistischer Software: R Sommersemester 2009 Kapitel 3,, Christian Foliengestaltung von Martin Dörr

2 Inhalt dieses Abschnitts 1 I 2 Vermeiden von, 3 und

3 Syntax if ( Bedingung ) { auszuführende Befehle wenn Bedingung TRUE } if ( Bedingung ) { auszuführende Befehle wenn Bedingung TRUE } else { auszuführende Befehle wenn Bedingung FALSE } Beachte: Die Bedingung in dieser Form darf nicht vektorwertig sein bzw. wird dann nur das erste Element des Vektors ausgewertet Die Bedingung kann ein komplexerer logischer Ausdruck sein, der entsprechend auch und (&&) und oder ( ) Verknüpfungen enthält I Vermeiden von, und 3.3

4 Beispiel > x <- 5 > if ( x==3 ) { x <- x-1 } else { x <- 2*x } > x [1] 10 I Vermeiden von, und 3.4

5 I Syntax ifelse(test,yes,no) (siehe auch die Online Hilfe) Dient der vektorwertigen Auswertung von Bedingungen. Dabei werden für die Komponenten, die in dem vektorwertigen logischen Ausdruck test den Wert TRUE liefern, die entsprechenden Operationen von yes durchgeführt. Für die Komponenten, die in dem vektorwertigen logischen Ausdruck test den Wert FALSE liefern, werden die entsprechenden Operationen von no durchgeführt. I Vermeiden von, und 3.5

6 Beispiel > x <- 1:10 > x [1] > ifelse( x<6, x^2, x+1 ) [1] I Vermeiden von, und 3.6

7 In Algorithmen (z.b. iterativen Algorithmen zur Maximierung der Likelihood wie Fisher Scoring oder Newton Raphson) oder in Simulationen müssen die gleichen Operationen mehrmals abgearbeitet werden. Wenn die Anzahl vorher bekannt ist (z.b. wenn Operationen für alle Untersuchungseinheiten i = 1,..., n durchgeführt werden sollen), so kann die for() Schleife verwendet werden. Syntax for (Name in Vektor ) { auszuführende Befehle } Eine Variable mit Namen Name wird auf alle Elemente gesetzt, die in dem Vektor enthalten sind. Anschließend werden alle Operationen für alle Werte dieser sequentiell ausgeführt. I Vermeiden von, und 3.7

8 Beispiel > for ( i in 1:5 ) { print( i^2 ) } [1] 1 [1] 4 [1] 9 [1] 16 [1] 25 > for ( i in c(2,4,6,7) ) { print( i^2 ) } [1] 4 [1] 16 [1] 36 [1] 49 I Vermeiden von, und 3.8

9 Noch ein Beispiel Häufig wird folgendes Konstrukt benutzt: > x <- 1:4 > for ( i in 1:length(x) ) { print( x[i]^3 ) } [1] 1 [1] 8 [1] 27 [1] 64 Daran ist zunächst nichts auszusetzen. Was passiert allerdings, wenn die Länge des Objekts 0 ist? > x <- NULL > length(x) [1] 0 > for ( i in 1:length(x) ) { print( x[i]^3 ) } numeric(0) numeric(0) D.h. die Schleife wird zweimal durchlaufen, da der Ausdruck 1:length(x) den Vektor (1, 0) zurückliefert: I Vermeiden von, und > 1:length(x) [1]

10 Noch ein Beispiel (Forsetzung) Deshalb ist es besser, den bereits eingeführten Befehl seq(along=x) zu verwenden, der einen Indexvektor erzeugt, der gleiche Länge wie x hat. > x <- 1:4 > for ( i in seq(along=x) ){ print( x[i]^3 ) } [1] 1 [1] 8 [1] 27 [1] 64 > x <- NULL > for ( i in seq(along=x) ){ print( x[i]^3 ) } > D.h. im zweiten Fall wird erwartungsgemäß nichts zurückgeliefert. I Vermeiden von, und 3.10

11 Wenn die Anzahl der zu durchlaufenden Operationen vorher nicht bekannt ist, z.b. wenn ein iterativer Algorithmus zur Maximierung der Likelihood solange durchgeführt werden soll, bis eine gewisse Konvergenzgenauigkeit erreicht ist, kann die while() Schleife verwendet werden. Syntax while(bedingung){ auszuführende Befehle solange Bedingung TRUE } Wenn die Bedingung bereits vor Eintritt in die Schleife nicht erfüllt ist, wird die Schleife überhaupt nicht durchlaufen. I Vermeiden von, und 3.11

12 Beispiel > i <- 1 > while (i<5) { + print(i^2) + i <- i+2 + } [1] 1 [1] 9 Hier muss der Programmmierer selbst darauf achten, dass die Variable i innerhalb der beiden geschweiften Klammern hochgezählt wird (ansonsten: Endlosschleife). I Vermeiden von, und 3.12

13 Noch ein Beispiel: Fibonacci Zahlen > Fib1 <- 1 > Fib2 <- 1 > Fibonacci <- c(fib1, Fib2) > while (Fib2 < 300) { + temp <- Fib1+Fib2 + Fibonacci <- c(fibonacci, temp) + Fib1 <- Fib2 + Fib2 <- temp + } > print(fibonacci) [1] Beachte: Befehle der Art Fibonacci <- c(fibonacci, temp) können sehr kostspielig im Sinne von Rechenzeit sein, wenn die Schleife sehr oft durchlaufen wird, da jedesmal die Länge des Vektors dynamisch vergrößert werden muss. Beispiel (beide Varianten liefern einen Vektor, der mit den Zahlen 1 bis belegt ist): > x <- c(1,2) > system.time( for (i in 3:30000) x <- c(x,i) ) User System verstrichen > > system.time( x <- 1:30000 ) User System verstrichen I Vermeiden von, und 3.13

14 testet im Gegensatz zur while() Schleife keine Bedingung vor Eintritt in die Schleife und auch nicht während des Durchlaufs der Schleife. Dafür ist der Progarmmierer zuständig, indem er an geeigneter Stelle einen break Befehl einbaut. Syntax repeat{ auszuführende Befehle } I Vermeiden von, und 3.14

15 Beispiel 1 > i <- 1 > repeat{ + print( i^2 ) + i <- i+2 + if ( i>10 ) break + } [1] 1 [1] 9 [1] 25 [1] 49 [1] 81 I Vermeiden von, und 3.15

16 Beispiel 2 Zusätzlich steht noch der Befehl next zur Verfügung, um zum Beginn der Schleife zurückzuspringen. > i <- 1 > repeat{ + i <- i+1 + if (i<10) next + print(i^2) + if (i>=13) break + } [1] 100 [1] 121 [1] 144 [1] 169 I Vermeiden von, und 3.16

17 Beispiel 3: Maximumssuche mit Newton Verfahren Aufgabe: Suche Nullstelle der 1. Ableitung > # Lokale Maximussuche, indem die Nullstelle der 1. Ableitung > # durch ein Newton-Verfahren bestimmt werden soll > # Gesucht x, so dass: f (x) = 0 > # Newton-Verfahren: x = x - f (x)/f (x) > > # Beispiel: f(x) = -0.5 x^2-2x +1 hat (sogar globales) Maximum in x=-2 > func <- function(x){ return(-0.5*x^2-2*x + 1) } > > # Zeichne Funktion im Bereich [-9,5] > curve(-0.5*x^2-2*x +1, -9, 5) > > # 1. Ableitung > dfunc <- function(x) { return(-x -2) } > > # 2. Ableitung > dfunc2 <- function(x) { return(-1) } > > # Newton-Verfahren > # Startwert: x0 > x0 <- 100 > # Toleranz definiert Abbruchbedingung > tolerance <- 1.0E-6 > # Schleife > x <- x0 > # Zähle die durchläufe > i <- 1 > repeat { + x <- x - dfunc(x)/dfunc2(x) + if ( abs(dfunc(x)) < tolerance ) break + i <- i+1 + } > cat("nullstelle der 1. Ableitung: ", x, "\n") Nullstelle der 1. Ableitung: -2 > cat("maximum der Funktion: ", func(x), "\n") Maximum der Funktion: 3 > cat("anzahl der durchläufe bis zur Konvergenz: ", i, "\n" ) Anzahl der durchläufe bis zur Konvergenz: 1 I Vermeiden von, und 3.17

18 Vermeiden von, Bei R handelt es sich um eine sog. Interpreter-Sprache, d.h. jeder Befehl wird erst zur Laufzeit interpretiert und ausgeführt (im Gegensatz zu kompilierten Sprachen) Insbesondere mit vielen Durchläufen, insbesondere auch ineinander geschachtelte, können sehr langsam sein, z.b. für den sequentiellen Zugriff auf alle Elemente X[i, j] einer Matrix Verwende, wenn möglich, spezielle Befehle, die eine Operation auf alle Elemente eines Objekts (Liste, Vektor, Matrix) anwendet Es stehen die Befehle apply(), lapply(), sapply(), mapply() und tapply() zur Verfügung Für die schnelle Berechnung von Zeilen und Spaltensummen, sowie von Zeilen und Spaltenmittelwerten, stehen die rowsums(),colsums(), rowmeans() und colmeans() zur Verfügung I Vermeiden von, und 3.18

19 lapply und sapply Diese sind für Listen (lapply()) und Vektoren gedacht. Dabei liefert lapply als Ergebnis eine Liste zurück, auch wenn der Eingabe Vektor als Elemente nur Skalare enthält. sapply() dagegen versucht, die Ergebnisse in diesem Fall als Array, Vektor, etc. auszugeben. Syntax lapply(x, FUN,...) sapply(x, FUN,..., simplify = TRUE, USE.NAMES = TRUE) I Vermeiden von, und 3.19

20 Beispiel 1 zu lapply und sapply > x <- 1:4 > lapply(x, function(x) x^2 ) [[1]] [1] 1 [[2]] [1] 4 [[3]] [1] 9 [[4]] [1] 16 > sapply(x, function(x) x^2 ) [1] I Vermeiden von, und 3.20

21 Beispiel 2 zu lapply und sapply > X <- matrix(nrow=2, ncol=2, data=7:10 ) > sapply(x, function(x){ x/2 } ) [1] > X2 <- matrix(nrow=2, ncol=2, data=1:4) > l1 <- list(x, X2) > lapply(l1, function(x){ x%*%x } ) [[1]] [,1] [,2] [1,] [2,] [[2]] [,1] [,2] [1,] 7 15 [2,] > sapply(l1, function(x){ x%*%x } ) [,1] [,2] [1,] [2,] [3,] [4,] Der letzte sapply() Befehl zeigt ein nachvollziehbares, aber vielleicht nicht das gewünschte Ergebnis. Im Fall, dass die Eingabeliste komplexe Objekte (hier: Matrizen) enthält, ist also der lapply() Befehl zu empfehlen. Neben sapply() existiert noch der verwandte Befehl replicate(), siehe Online Hilfe. I Vermeiden von, und 3.21

22 apply für Matrizen Syntax apply(x, MARGIN, FUN,...) Die Argumente sind die Eingabematrix X die beizubehaltende Dimensionsnummer (1 für Zeilen, 2 für Spalten) die auf jede Zeile bzw. jede Spalte anzuwendende Funktion. Dabei kann es sich wiederum um bereits in R definierte oder eine selbst definierte Funktion handeln. Definiert man die Funktion erst beim Aufruf von apply() als FUN Argument, so spricht man von einer anonymen Funktion, da diese nach Ausführen des Befehls nicht mehr bekannt ist I Vermeiden von, und 3.22

23 Beispiele zu apply > X <- matrix( nrow=3, ncol=2, byrow=t, data=4:9 ) > X [,1] [,2] [1,] 4 5 [2,] 6 7 [3,] 8 9 > apply(x,1,max) [1] > apply(x,2,min) [1] 4 5 I # liefert den Index des jeweils maximalen Elements einer Zeile zurueck > apply(x,1, which.max) [1] Vermeiden von, und # eigene Funktion > apply(x,2, function(x){ max(x)-min(x) } ) [1]

24 tapply für Datensätze Die Idee von tapply() ist die Anwendung auf Datensätze zur Berechnung zusammenfassender Statistiken einer Variable bezüglich der Gruppierung nach einer anderen Variable. Im folgenden Beispiel ist x ein numerischer Vektor und fac ein Faktor. Es soll die Summe in x, gruppiert nach fac berechnet werden. Beispiel > x <- 1:10 > fac <- factor( c(1,1,1,1,1,2,2,2,2,2) ) > tapply( x, fac, sum ) tapply() liefert 2 Werte zurück, und zwar 15 für den Faktorwert 1 und 40 für den Faktorwert 2. D.h. es wurde die Summe der Zahlen von 1 bis 5 berechnet (15, Faktorstufe 1) und die Summe der Zahlen von 6 bis 10 (40, Faktorstufe 2). I Vermeiden von, und 3.24

25 mapply Der Befehl mapply() ist eine Art multivariate Version von sapply(). Folgendes Beispiel ist der Online Hilfe entnommen. Beispiel > mapply(rep, times=1:4, x=4:1) [[1]] [1] 4 [[2]] [1] 3 3 [[3]] [1] [[4]] [1] I Vermeiden von, und 3.25

26 Syntax sind Programmiereinheiten, die einen wohldefinierten Zweck haben übernehmen Inputvariablen, führen Berechnungen durch (oder erzeugen Grafiken, rufen andere auf, etc.) und produzieren Ausgaben und Ausgabevariablen Name <- function(argument1, Argument2,...) Ausdruck wobei Ausdruck eine einzelne Anweisung oder eine Folge von Anweisungen sein kann. In letzterem Fall müssen die Anweisungen in geschweiften Klammern stehen. I Vermeiden von, und 3.26

27 Beispiel: Berechnung der t-statistik (1 Stichprobe) onesample.tstatistik <- function(x){ n <- length(x) if (n<2) stop("length of input vector should at least be 2") num.na <- sum( is.na(x) ) if ( num.na > 0 ){ cat("note: vector of length ",n," contains ", num.na, " missing values which are omitted.\n") n <- length(x) - num.na if (n<2) stop("after omitting NAs, less than 2 observations remain for calculating the t statistics") } mx <- mean(x, na.rm=true) sx <- sd(x, na.rm=true) tstatistik <- mx / ( sx/sqrt(n) ) return( tstatistik ) } I Vermeiden von, und 3.27

28 Funktionsargumente mit Namen und Voreinstellungen Funktionsargumente können Namen haben Funktionsargumente können mit Werten vorbelegt werden können das Argument... enthalten Beispiel # Funktion zum Auswerten und Zeichnen von f.printplot <- function(func, xvalues=seq(from=0,to=1,by=0.1), plot=true, print=false,...){ function.values <- func(xvalues) if (plot) plot(xvalues, function.values,...) if (print) return( cbind(xvalues, function.values) ) else return(null) } # Definiere eine Funktion square <- function(x) x^2 I Vermeiden von, und # Aufruf mit verschiedenen Einstellungen f.printplot(square, type="l") f.printplot(square, xvalues=seq(from=-2,to=2,by=0.1), type="l") f.printplot(square,print=t, pch="*") 3.28

29 Normale Zuweisungen an in haben nur lokalen Gültigkeitsbereich und sind temporär. Ausnahme: assign() und superassignment Operator <<-, die außerhalb von (z.b. in der R-Konsole) angelegt werden haben globalen Gültigkeitsbereich und sind in sichtbar. In der Funktion kann eine Variable mit dem Namen einer globalen Variable verwendet werden, welche dann wiederum nur lokal sichtbar ist. I Vermeiden von, und 3.29

30 : Beispiel 1 # Beispiel zur lokalen Sichtbarkeit von, globales Assignment globalx <- 10 f <- function() { x <- 1 g() assign("globalx", 5, envir =.GlobalEnv) return(x) } g <- function() { x <- 2 } f() globalx Ergebnis > f() [1] 1 > globalx [1] 5 I Vermeiden von, und 3.30

31 : Beispiel 2 y <- 1 h <- function() { y <- y+1 return(y) } h() h() y I Ergebnis > h() [1] 2 > h() [1] 2 > y [1] 1 Vermeiden von, und 3.31