Statistisches Programmieren

Transkript

1 Statistisches Programmieren Session 2 1 Funktionsdefinitionen Berechnungen die immer wieder in ähnlicher Form auftreten, müssen nicht jedesmal vollständig neu in der R Konsole eingeben werden, sondern können zu Funktionen zusammengefasst werden. Um eine Funktion in R zu schreiben verwendet man das Schlüsselwort function. Der Aufbau einer R Funktion ist wie folgt. funktionsname.r funktionsname < function(arg1,..., argn) { Befehlsfolge bestehend aus arithmetischen Berechnungen, Variablenzuweisungen, Schleifen, Funktionsaufrufen,... return(resultat) Die Schlüsselworte function und return markieren hierbei den Anfang bzw den Rückgabewert (und somit das Ende) der Funktion. Die Argumente (hier arg1 bis argn) und der Funktionsname (hier funktionsname) werden mittels des function Befehls spezifiziert. Grundsätzlich sollten - wie auch für Variablen - für Funktionen bzw deren Argumente sprechende Namen verwendet werden, um das Lesen des Codes einfacher zu machen und extensive Kommentare zu vermeiden. Eine einfache Funktion wäre zb die Berechnung des Medians einer empirischen Verteilung (gegeben durch einen Vektor von Werten). med.r med < function(daten) { sorteddata <- sort(daten, decreasing = FALSE); return( sorteddata[ floor((length(daten)+1)/2) ]); Die Funktion length() in der obigen Funktion ermittelt die Länge eines Vektors. Variablen die innerhalb einer Funktion erzeugt werden sind lokal, d.h. sie werden bei dem Funktionsaufruf angelegt und nach der Termination der Funktion wieder gelöscht. Ein Benutzer der die Funktion von der Konsole aufruft 1

2 (oder eine andere Funktion) können auf die Werte dieser lokalen Variablen weder lesend noch schreibend zugreifen. Hat man eine Funktion fertig gestellt, so gibt es zwei Arten sie in das R- System zu laden 1. man gibt den Code in die Konsole ein oder 2. man speichert die Funktion in einer Datei mit Endung.R ab und lädt sie mit dem Befehl source() Hat man zum Beispiel obige Funktion in dem File med.r gespeichert und im Verzeichnis c:\ meineprogramme abgelegt, dann würde man wie folgt vorgehen. > setwd( c:/meineprogramme ) > source( med.r ) > datapoints <- c(1, 2234, 23, 2, 3) > med(datapoints) [1] 3 Wenn man den Code einer beliebigen Funktion ansehen will, so kann man sich den Quelltext anzeigen lassen indem man nur den Funktionsnamen (ohne Klammern oder Argumente) eingibt. 2 Branching Beim Schreiben von Funktionen tritt oft eine Situation ein, in der man zwischen unterschiedlichen Fällen unterscheiden will und abhängig von dem Wert gewisser Variablen bestimmte Instruktionen ausführen will oder auch nicht. Solche Unterscheidungen trifft man mit den Befehlen if und else. Zum Beispiel könnte man folgende Erweiterung von med.r betrachten. 2

3 medextended.r med <- function(daten) { sorteddata <- sort(daten, decreasing = FALSE); l = length(daten); # Bei einer geraden Anzahl an Datenpunkten wird das # arithmetische Mittel der beiden mittleren # Datenpunkte ausgegeben. if (l%%2==0) { return(.5*(sorteddata[length(daten)/2]+sorteddata[length(daten)/2+1])); else { return(sorteddata[(length(daten)+1)/2]); Das Schlüsselwort if() empfängt als Argument also einen logischen Wert. Ist dieser TRUE, dann wird der nachfolgende Codeblock zwischen den geschwungenen Klammern ausgeführt. Wird der Wert FALSE übergeben wird der Codeblock übersprungen und gegebenenfalls der Codeblock der auf else folgt ausgeführt. Die Verwendung von else ist hierbei optional. In dem obigen Beispiel wurde das Zeichen # verwendet, um Kommentare in den Code einzufügen. Bei längeren oder komplexeren Codes empfiehlt es sich, immer ein kurzes Kommentar anzufügen, das die Funktionsweise erklärt. 3 Loops Will man ein Codestück öfter in nur leicht veränderter Form anwenden, dann bietet sich die Verwendung von Schleifen an. 3.1 for-loops For-Schleifen führen ein Codestück iteriert aus. Hierbei wird eine Schleifenvariable in einem vorher angegebenen Bereich verändert. Richtig eingesetzt sollte diese Änderung der Schleifenvariablen bewirken, dass der Code in der richtigen Weise iteriert wird. Als Beispiel betrachten wir die Function gauss.r, welche die Summe der Zahlen von 1 bis obergrenze bilden soll. Um diese Summe zu errechnen, werden wir (ineffizienter Weise, die Formel für das Ergebnis ist ja hinlänglich bekannt) eine For-Schleife verwenden. 3

4 gauss.r gauss <- function(obergrenze) { result <- 0; for(i in 1:oberGrenze) { result <- result + i; return(result) Die Schleifenvariable i läuft hier über alle Zahlen zwischen 1 und obergrenze und wird in dem Codestück zwischen den geschwungenen Klammern verwendet, um die gewünschte Summe aufzubauen. Der Syntax von for ist hierbei for(schleifenvar in vektor) { CodeBlock. Beachte, dass for über allgemeine Vektoren iterierten kann, so ist zum Beispiel auch folgende Verwendung zulässig. it <- c(3, 6, 9, 12) sum <- 0 for(i in it) { sum = sum + i sum [1] while-loops While-Schleifen unterscheiden sich von For-Schleifen darin, dass es a priori keine Schleifenvariablen gibt und das somit die Abbruchbedingung manuell erstellt werden muss. Der Syntax lautet while(logical) { CodeBlock. Der Codeblock wird so lange ausgeführt, bis die logische Variable in der Klammer FALSE wird. Ein Beispiel für den Einsatz von while Schleifen liefert das inverse Problem zu obiger Funktion gaus.r. gaussinv.r gaussinv <- function(treshhold) { s <- 0; add <- 0; while(s < treshhold) { add <- add + 1; s <- s + add; return(add); 4

5 Die Funktion gausinv.r gibt offensichtlich an, bis wohin man in der arithmentischen Reihe summieren muss, bis die entsprechende Partialsumme größer als treshhold ist. Hier werden einerseits die Partialsummen in der Variable s gespeichert, welche für die Abbruchbedingung gebraucht wird und andererseits wird mittels der Variablen add mitgezählt wieviele Zahlen schon summiert wurden (Rückgabe). 4 Rekursion Oft erweist es sich als praktisch, Probleme statt mittels Schleifen mittels rekursiver Programmierung zu lösen. Hierbei wird ein Problem gelöst indem es in geeigneter Weise in kleinere Probleme des gleichen Typs ausgespalten wird. Dies wird so lange wiederholt bis das resultierende Problem eine triviale Lösung hat. Oft lassen sich auf diese Weise Aufgaben, die sonst mit Schleifen gelöst werden müssten, elegant behandeln. Ein einfaches Beispiel liefert die folgende Funktion, die n! berechnet. fact.r fact <- function(n) { if(n==1) { return(1); else { return(n * fact(n-1)); Man beachte, dass sich die Funktion fact() selbst aufruft, um die Lösung für ein bestimmtes n zu finden. Theoretisch können alle Probleme die mittels Schleifen behandelt werden auch mittels Rekursion behandelt werden und umgekehrt. Das Prinzip der Schleife ist wiederholte Ausführen des selben Schrittes, das Prinzp der Rekursion hingegen das ineinander Schachteln von Problemen. Oft sind Implementationen die sich Schleifen bedienen solchen die auf Rekursionen basieren vorzuziehen, da Schleifen in der Regel von Programmiersystemen (vor allem bei kompilierten Programmen) effizienter verarbeitet werden können als Rekursionen. Andererseits gibt es aber auch Probleme, bei denen eine rekursive Programmierung die natürliche Wahl ist (dies wird im nächsten Beispiel und in der Übungsaufgabe 9 deutlich). Ein weiteres Beispiel für die Anwendung von rekursiven Verfahren sind die sogenannten Türme von Hanoi. Es handelt sich hierbei um ein Geduldspiel. Das Spielbrett besteht aus 3 Stäben auf denen Scheiben aufgereiht sind, wobei keine 5

6 zwei Scheiben gleichen Durchmesser haben. Zu Anfang des Spieles liegen alle Scheiben auf dem linken Stab. Ziel des Spieles ist es, die Scheiben auf den rechten Stab zu befördern. Hierbei sind alle Züge zulässig in denen die oberste Scheibe eines Stapels auf die oberste Postions eines zweiten Stapels verschoben wird und zusätzlich die Bedingung gilt, dass die Scheiben auf jedem Stapel jeweils nach Größe geordnet (die kleinste zu Oberst) zu liegen kommen. Nachstehend eine rekursive Implementation, die eine Spielstrategie für eine Ausgangssituation mit beliebig vielen Scheiben liefert. hanoi.r hanoi <- function(discs, s1, s2, s3) { if(discs>1) { return(rbind(hanoi(discs-1,s1,s3,s2),c(s1,s3),hanoi(discs-1,s2,s1,s3))); else { return(c(s1, s3)); hanoi(...) löst durch den Aufruf hanoi(n, 1, 2, 3) im Prinzip das obige Problem für beliebige Anzahl an Scheiben n auf elegante und kompakte Art. Es ist allerdings hinzuzufügen, dass die Anzahl der notwendigen Schritte exponential steigt (für n Scheiben werden mindestens 2 n 1 Züge benötigt). Für drei Scheiben liefert das Programm die folgenden sieben Züge. hanoi(3, 1, 2, 3) [,1] [,2] [1,] 1 3 [2,] 1 2 [3,] 3 2 [4,] 1 3 [5,] 2 1 [6,] 2 3 [7,] 1 3 Der erste Zug geht also von Stapel 1 nach Stapel 3, der zweite von Stapel 1 nach Stapel 2 und so weiter. 6

7 5 Beispiele 1. Erstelle eine Funktion prim(n), die einen Vektor aller Primzahlen von 2 bis n ausgibt. Hinweis: implementiere das sogenannte Sieb von Eratosthenes (siehe 2. Erstelle eine Funktion isschaltjahr(jahreszahl), die TRUE zurückgibt, wenn es sich bei dem Jahr jahreszahl um ein Schaltjahr handelt und FALSE sonst. Für die Definition von Schaltjahren siehe org/wiki/schaltjahr. 3. Erstelle eine Funktion bubblesort(inputvector), welche die Zahlen in inputvector aufsteigend ordnet. Gehe hierbei so vor, dass zuerst die kleinste Zahl an die erste Stelle verschoben wird, dann die zweitkleinste an die zweite und so weiter (siehe Verwende nicht die von R zur Verfügung gestellten Suchroutinen. 4. Erstelle eine Funktion transpose(inputmatrix), welche die Matrix input- Matrix transponiert. Greife hierbei nicht auf die in R eingebauten Matrixfunktionen zurück. 5. Erstelle Funktionen die folgende Summen errechnen mittels Schleifen errechnen (a) Die Summe der p-ten Potenzen aller durch k teilbaren Zahlen von 1 bis n. Die Variablen k und p sollen der Funktion hierbei übergeben werden. (b) Die Summe der ersten n Glieder der Fibonacci-Folge. Fibonacci- Folge: 6. Erstelle eine rekursive Funktion, die die n-te Fibonacci Zahl ausgibt. 7. Erstelle eine rekursive Funktion zum Berechnen von a n, falls a n = 2a n 1 + ( 1) n a n 2, n 2. Die Anfangswerte a 0 und a 1 sollen hierbei als Parameter spezifiziert werden können. 8. Um den größten gemeinsamen Teiler zweier ganzer Zahlen x und y zu finden, kann man folgendermaßen rekursiv vorgehen { ggt (y, x%%y), y 0 ggt (x, y) = x, y = 0. Hierbei meint (entsprechend der R Notation) x%%y den Rest bei der Division von y durch x. (a) Implementiere obige Methode zum Auffinden des größten gemeinsamen Teilers. 7

8 (b) Implementiere eine Funktion, die den größten gemeinsamen Teiler zweier ganzer Zahlen x und y findet, ohne dabei das Prinzip der Rekursion zu benutzen. Verwende eine Schleifenformulierung. 9. Implementiere die Funktion mergesort(unsorted) zum Sortieren der Zahlen im Vektor unsorted. Verwende eine rekursiven Ansatz. Siehe für eine Beschreibung von Merge-Sort. 8