Walter Zucchini                                           Georg-August-Universität Göttingen

Kristin Neumann                                        Institut für Statistik und Ökonometrie

Andreas Stadie

 

                                                                                                 

 

 

EINFÜHRUNG IN R

 

 

 

 

1  Einleitung

In den Veranstaltungen des Instituts für Statistik und Ökonometrie wird das Statistikprogrammpaket R eingesetzt. R ist ein Softwarepaket, das frei im Internet verfügbar und leicht zu installieren ist (eine Installationsbeschreibung befindet sich in Anhang ). Es gibt sowohl eine R-Version für Windows als auch eine für Unix. R ist - von einigen Befehlen und dem Layout abgesehen - identisch zu dem bisher an diesem Lehrstuhl verwendeten Paket S-PLUS.

Mit R können Datenanalysen und Modellanpassungen anschaulich und übersichtlich ausgeführt werden. Im Bereich der graphischen Datenanalysen stehen beispielsweise Histogramme, Boxplots, Quantil-Quantil-Plots und viele weitere Plot-Möglichkeiten zur Verfügung. Das Programm ist sowohl im Bereich der Zeitreihenanalyse als auch für die im Rahmen der Varianzanalyse und der verallgemeinerten linearen Modelle erforderlichen Modellanpassungen geeignet. Auch für die Anwendung von Bootstrap-Verfahren ist eine leistungsfähige Software unverzichtbar.

Ist die grundsätzliche Arbeitsweise von R einmal verstanden, kann das Programmpaket auch für das Programmieren eigener Funktionen und somit zum Lösen anwenderspezifischer Probleme verwendet werden.

Durch die folgende Einführung soll das erste Arbeiten mit R ermöglicht und erleichtert werden - sie kann allerdings selbständiges Üben und Erfahrungsammeln durch Ausprobieren nicht ersetzen. Die in den Abschnitten jeweils wichtigen behandelten Befehle werden am Textrand nochmals genannt, um ein schnelleres Wiederholen und eine bessere Übersicht zu gewährleisten.

2  Erste Schritte

2.1  Starten und Beenden

Ist das Programm R installiert, muß zum Starten von R lediglich die Datei `rgui.exe' ausgeführt werden. Im CIP-Pool erfolgt dies, indem der button `R' direkt mit einem Doppelklick angesprochen wird. Das Programm startet, und nach kurzer Zeit erscheint ein Fenster, in dem in Blau einige Hinweise (beispielsweise zum Verlassen von R) und in Rot ein Cursor nach dem Prompt-Zeichen (>) zu sehen sind. Immer wenn dieses Prompt-Zeichen erscheint, ist R bereit, Befehle des Users entgegenzunehmen und zu verarbeiten.

Möchte man R verlassen, kann man entweder den Befehl q() hinter dem Prompt-Zeichen (mit nachfolgender Enter-Taste) eingeben, oder man klickt auf der Menüleiste (am oberen Bildschirmrand) rechts in der Ecke das Kreuz zum Schließen des R-Fensters an. In beiden Fällen erscheint in einem Dialogfenster die Frage, ob die in der Sitzung gewonnenen Daten für ein weiteres Arbeiten in der nächsten Sitzung gespeichert werden sollen. Klickt man `yes' an, werden die Daten gespeichert, ansonsten nicht.

2.2  Hilfefunktionen

Unter den in Abschnitt 2.1 genannten Hinweisen befindet sich auch einer auf die Hilfefunktion in R: Diese kann mit help(befehl) aufgerufen werden. Hierbei muß in Klammern befehl durch den Befehl ersetzt werden, über den eine Auskunft gewünscht wird. HINWEIS: Diese kursive Schreibweise wird im folgenden immer verwendet, wenn ein Platzhalter für viele mögliche Ausdrücke gemeint ist, der in der Eingabe in R durch einen speziellen Ausdruck ersetzt werden muß. Alternativ zu dem Befehl help(...) kann auch das Kommando ?befehl verwendet werden.

Eine weitere Möglichkeit zur Inanspruchnahme der Hilfefunktion besteht in der Nutzung menügesteuerter Hilfen: Auf der Menüleiste (oberer Bildschirmrand) befindet sich der Menüpunkt `Help', unter dem sowohl die Standardhilfe von R (hier wird nach Aufruf in einem Dialogfenster wiederum nach dem Befehl gefragt, über den Informationen gewünscht sind) als auch eine Hilfe im html-Format aufgerufen werden kann (bei Verwendung dieser Hilfe muß man sich nicht im Internet anmelden). Wird letztere verwendet, kann über den Link `Functions' auf die Hilfe zu allen verfügbaren, alphabetisch geordneten Funktionen zugegriffen werden. Vorteil dieser Hilfe ist, daß zum einen alle Funktionen alphabetisch aufgelistet sind und daß man zum anderen bei Hinweisen auf andere in diesem Zusammenhang wichtige Funktionen direkt durch Anklicken auf diese zugreifen kann, während die Standardhilfe für den ``Folgebefehl'' wieder neu aufgerufen werden muß. Die jeweilige Hilfeseite kann durch Klicken auf das Kreuz rechts oben in der Ecke geschlossen werden.

Für eine ausführliche Dokumentation von R steht unter dem Menüpunkt `Hilfe' zusätzlich das sogenannte `manual' zur Verfügung.

2.3  Eingabe und Ausführen von Befehlen

Ist der Cursor nach dem Promptzeichen zu sehen, ist R - wie bereits erwähnt - zur Eingabe von Befehlen bereit. Ein möglicher Befehl wäre beispielsweise 3+5. Nach dem zusätzlichen Drücken der Return (oder auch Enter)-Taste führt R diesen Befehl aus und gibt das Ergebnis auf dem Bildschirm aus. Auf dem Bildschirm sieht die vollständige Einheit wie folgt aus (auf die jeweilige Angabe der Return-Taste sei hier und im folgenden verzichtet):

>3+5
[1] 8
>

2.4  Rechenoperationen

In R ist es ohne weiteres möglich, die gängigen Rechenoperationen durchzuführen. Die anzuwendenden Befehlskombinationen bedürfen in vielen Fällen keiner Erklärung mehr, beispielsweise steht exp(4) für die Exponentialfunktion an der Stelle 4, und man erhält als Ergebnis 54.59815. Die wichtigsten Befehle für solche Rechenoperationen sind die folgenden:
>3+5Addiert 3 zu 5
>3-5Subtrahiert 5 von 3
>3*5Multipliziert 3 mit 5
>3/5Dividiert 3 durch 5
>3^ 5Berechnet 3 ``hoch'' 5
>sqrt(3)Berechnet die Quadratwurzel aus 3
>log(3)Berechnet den natürlichen Logarithmus von 3

2.5  Speichern von Ergebnissen in Objekten

Oftmals ist es nicht gewünscht, daß das errechnete Ergebnis eines Befehls auf dem Bildschirm ausgegeben wird, sondern daß es zur späteren Weiterverarbeitung im Direktzugriff zur Verfügung steht. Dies kann erreicht werden, indem der auszuführenden Operation ein Name zugewiesen wird. Möchte man beispielsweise das Ergebnis 8 aus der Operation 3+5 für weitere Berechnungen unter dem Namen summe speichern, würde dies folgendermaßen aussehen:

summe<-3+5
>

Durch die Zeichenfolge <- wird dem Namen summe das Ergebnis der nachfolgenden Operation zugewiesen. Nach Ausführen des Befehls erscheint das Ergebnis also nicht auf dem Bildschirm, sondern die Return-Taste bewirkt lediglich das Abspeichern des Ergebnisses der Operation unter summe. Möchte man sich das Ergebnis ansehen, ist dies durch Eingabe von summe mit nachfolgender Return-Eingabe möglich:

>summe
>[1] 8

>

Mit dem unter summe abgespeicherten Ergebnis kann dann wie mit einer gewöhnlichen Zahl weitergerechnet werden, beispielsweise folgendermaßen:

>produkt<-summe*4
>

Hiermit wird das Produkt aus summe und 4 berechnet und das Ergebnis (hier 32) dem Namen produkt zugewiesen. Durch Eingabe von produkt überzeuge man sich von der Richtigkeit des Ergebnisses!

Allgemein werden alle Ergebnisse von Operationen, denen ein Name zugewiesen wurde, auch Objekte genannt.

2.6  Auflisten und Löschen von Objekten

Hat man bereits mehrere Operationen in R durchgeführt und auch schon einigen davon Namen zugewiesen, ist es oft sinnvoll, sich einen Überblick über die vorhandenen Objekte zu verschaffen. Dies ist mit dem Befehl ls() möglich. Als Ergebnis erhält man eine Liste der vergebenen Namen in alphabetischer Reihenfolge, in diesem Fall ergibt sich also

>ls()
[1] "produkt"     "summe"
>

Benötigt man eines der Objekte nicht mehr, kann man dieses löschen, indem man den Befehl

>rm(name)
>

eingibt. Das Objekt mit dem Namen name ist dann gelöscht.

2.7  Häufig auftretende Fehler

Beim ersten Arbeiten mit R wird es häufig vorkommen, daß Befehle unvollständig oder fehlerhaft eingegeben werden. Im folgenden wird auf einige dieser Fehler sowie sonstige Irrtümer hingewiesen.

Klammersetzung   Da beim Arbeiten mit R sehr viele Klammern verwendet werden, passiert es häufig, daß Befehle nicht ausgeführt werden können, da Klammern nicht korrekt gesetzt sind. Zu beachten ist dabei auch, daß R runde, eckige und geschweifte Klammern verwendet und diese auch unterscheidet, daß einer geöffneten eckigen Klammer also ``irgendwann'' eine geschlossene eckige Klammer folgen muß. Ist ein Befehl bei Eingabe der Return-Taste noch nicht vollständig, erscheint in der nächsten Zeile statt des Prompt-Zeichens ein +, das zur Vervollständigung des Befehls auffordert:

>sqrt(3
+

Möchte man den Befehl vervollständigen, gibt man in diesem Fall nach dem + eine runde Klammer ein und drückt Return:

+)
[1] 1.732051
>

Findet man den Fehler nicht oder möchte man den Befehl aus anderen Gründen nicht vervollständigen, bricht man den Befehl mit der Esc-Taste oder durch Anklicken des roten Stop-button in der Menüleiste ab; es erscheint ohne Ausgabe eines Ergebnisse das Prompt-Zeichen.

Groß- und Kleinschreibung   R unterscheidet Klein- und Großbuchstaben. Weist man also einem Ergebnis den Namen summe zu und versucht man, das Ergebnis mit dem Befehl Summe abzurufen, wird folgende Fehlermeldung erscheinen (soweit man nicht vorher ein Objekt Summe definiert hat):

>Summe
Error: Object "Summe"  not found
>

Überschreiben von Objekten   Hat man einen Namen vergeben und verwendet diesen zur Zuordnung ein zweites Mal, überschreibt R das vorher unter diesem Namen gespeicherte Objekt ohne Warnung, das alte unter diesem Namen gespeicherte Objekt kann nicht mehr abgerufen werden. Beispiel:

>test<-4*5
>test<-20*5
>test
[1] 100
>

3  Daten- und Objektarten

3.1  Datenarten

Wie allgemein bei Programmiersprachen üblich, unterscheidet auch R unterschiedliche Datenarten:

Standardmäßig interpretiert R alle Daten als numerisch. Um Daten als alphabetische Daten kenntlich zu machen, müssen diese in Anführungszeichen gesetzt werden. Versucht man, Kristin unter dem Namen vorname abzuspeichern, funktioniert dies folglich nur, wenn folgender Befehl eingegeben wird:

>vorname<-"Kristin"
>

Werden die Anführungszeichen weggelassen, gibt R die folgende Fehlermeldung aus, weil R ein unter diesem Namen gespeichertes Objekt sucht und kein solches findet:

>vorname<-Kristin
Error: Object "Kristin"  not found
>

Hingegen werden die Ausdrücke T und F für die logischen Werte `wahr' (True) respektive `falsch' (False) ohne besondere Kennzeichnung als logische Daten erkannt:

>logik<-T
>logik
[1] True
>

3.2  Objektarten

In R existieren unterschiedliche Objektarten, die je nach Problemstellung zur Datenspeicherung und -verarbeitung geeignet sind. Vektoren und Matrizen, die vom Aufbau her wahrscheinlich am leichtesten zu verstehen sind, werden im folgenden näher erläutert. Weiterhin unterscheidet R Arrays (Felder, die eine Verallgemeinerung von Matrizen darstellen und nicht nur zwei, sondern mehr Dimensionen zulassen), Data Frames (in Data Frames lassen sich verschiedene Objekt- und Datenarten zusammenfassen, solange sie dieselbe Zeilenzahl haben) und Listen (Listen sind Verallgemeinerungen von Data Frames und können als Elemente auch wieder Listen enthalten). Letztgenannte Objektarten werden in dieser ersten R-Einführung nicht ausführlicher erläutert. 1

Im weiteren Sinn können auch die in Abschnitt 5 behandelten Funktionen als R-Objekte bezeichnet werden.

Vektoren   Vektoren sind eindimensionale Datenfelder. In Vektoren können mehrere einzelne Elemente zu einer Einheit zusammengefaßt werden. Vektoren können entweder aus numerischen, logischen oder alphabetischen Daten bestehen. Die Daten werden beispielsweise durch den Befehl c(d1,d2,...) verbunden, wobei d1,d2,... für die zu verbindenden Elemente stehen (weitere Befehle zur Erzeugung von Vektoren finden sich in Abschnitt 5.2.1). Ein Beispiel mit numerischen Daten ist:

> c(1,5,7,9,11)
[1] 1 5 7 9 11
>

Selbstverständlich kann dieser Ausdruck dann auch wieder unter einem Namen abgespeichert und dadurch abrufbar gemacht werden:

> vektor<-c(1,5,7,9,11)
>

Ein Vektor kann auch aus logischen Daten

> c(T,T,F,F,T,F)
[1] True True False False True False
>

oder aus alphabetischen Daten bestehen:

> c("Kristin", "Stadie", "Sebastian")
[1] "Kristin"  "Stadie"  "Sebastian"
>

Die Datenarten sollten allerdings in einem Vektor nicht gemischt werden, da R dann alle Daten in eine Datenart (je nach Art der eingegebenen Daten, im Beispiel in Character-Daten) umwandelt:

> c("Kristin",9,F)
[1] "Kristin"  "9"  "F"
>

Matrizen   Matrizen sind zweidimensionale Datenfelder. Der Umfang solcher Matrizen wird durch die Angabe der Anzahl von Zeilen und der Anzahl von Spalten festgelegt. Mit
matrix(data,ncol,nrow,byrow) können solche Matrizen erstellt werden. Eine Erklärung zu den kursiv gedruckten Argumenten der Funktion kann auch der Hilfefunktion entnommen werden. Als erstes Argument werden die Daten eingegeben, wobei diese in Vektorform eingegeben werden müssen. Mit ncol wird die Anzahl der Spalten der Matrix festgelegt, mit nrow die Anzahl der Zeilen der Matrix. Es reicht aus, eines der beiden letztgenannten Argumente anzugeben, da der Aufbau der Matrix durch die Anzahl der Elemente im Datenvektor in Verbindung mit der Angabe eines der beiden Argumente bereits vollständig festgelegt ist. Standardmäßig werden die Daten eingelesen, indem zuerst die erste Spalte von oben nach unten vollständig gefüllt wird, dann die zweite Spalte, die dritte Spalte usw. Wird die Option byrow allerdings auf T (True) gesetzt, erfolgt das Auffüllen der Matrix zeilenweise. Hier einige Beispiele:

>matrix(c(1,2,3,4,5,6,7,8),ncol=4)
[,1][,2][,3][,4]
[1,]1357
[2,]2468

>


>matrix(c(1,2,3,4,5,6,7,8),ncol=2)
[,1][,2]
[1,]15
[2,]26
[3,]37
[4,]48

>


>matrix(c(1,2,3,4,5,6,7,8),ncol=2,byrow=T)
[,1][,2]
[1,]12
[2,]34
[3,]56
[4,]78

>

In Matrizen können - analog zu den Vektoren - auch andere Datenarten als numerische Daten stehen. Es gelten die dort genannten Regeln.

3.3  Einlesen von Daten

Daten können auf verschiedenen Wegen in R eingelesen werden. Sollen Daten manuell erfaßt werden, können die Daten entweder mit Hilfe des Befehls c(...) direkt als Vektor eingegeben werden (siehe Abschnitt 3.2.1), oder die Daten werden mit dem Befehl scan(...) erfaßt. Dieser Befehl hat mehrere Argumente, von denen in dieser Einführung nur einige genannt werden (Näheres hierzu ist der R-Hilfe zu entnehmen). Möchte man mit manueller Dateneingabe durch scan(...) dem Objekt werte die Daten 4,5,6 zuordnen, können nach Eingabe des Befehls
scan() die Daten erfaßt werden, indem die einzelnen Daten durch Eingabe der Return-Taste (oder der Leertaste) getrennt eingegeben werden. Die Eingabeprozedur wird durch zweimaliges Drücken der Return-Taste beendet. Die Befehlsfolge sieht dann folgendermaßen aus:

> werte<-scan()
1: 4
2: 5
3: 6
4:
Read 3 items
>

Für die manuelle Erfassung von Daten wird der Befehl scan(...) eher selten gebraucht. Es ist mit diesem Befehl aber auch möglich, Daten aus einer Datei einzulesen. Hierbei wird als Argument file der Funktion die Quelle der einzulesenden Daten in Anführungszeichen eingegeben. Angenommen, man möchte aus der Datei K:\Splus\daten\foodx.dat Daten unter dem Namen speisen einlesen, lautet der zugehörige Befehl (wichtig ist die korrekte Eingabe der doppelten backslashs!):

> speisen<-scan(file="K:\\Splus\\daten\\foodx.dat")
Read 148 items
>

Hierbei ist darauf zu achten, daß mit diesem Befehl nur Daten im Vektorformat gelesen werden können und daß das Ergebnis dieser Form des Einlesens ein Vektor ist. Möchte man Tabellen (eventuell mit Zeilen- und Spaltennamen) einlesen und diese auch als Tabellen erhalten, ist der Befehl read.table(...) besser geeignet. Auch dieser Befehl hat mehrere Argumente, von denen an dieser Stelle nur zwei erläutert werden. Angenommen, es sollen die Daten K:\Splus\daten\icecream.dat unter dem Namen eis eingelesen werden (Hinweis: Der Datensatz enthält den Eiskonsum in den USA mit mehreren, eventuell den Konsum erklärenden Einflußvariablen). Der zugehörige Befehl lautet

> eis<-read.table(file="K:\\Splus\\daten\\icecream.dat")
>

R weist den Spalten und Zeilen automatisch Variablennamen und Zeilennummern zu. Wird das Objekte eis betrachtet, wird deutlich, daß in der Quelldatei bereits Variablennamen enthalten sind. Möchte man diese auch als Variablennamen kennzeichnen, kann dies durch die Option header=T geschehen:

> eis<-read.table(file="K:\\Splus\\daten\\icecream.dat",
+header=T)
>

In der Regel ist es sinnvoll, sich die Daten vor dem Einlesen in einem Editor anzuschauen, um sich über den passenden Einlesebefehl klarzuwerden. Immer wenn die Daten beispielsweise Variablenbezeichnungen enthalten, kann der Befehl scan(...) wegen der unterschiedlichen Datenformate nicht verwendet werden.

HINWEIS: R kann Verzeichnisse und Dateien nur dann lesen, wenn die jeweiligen Verzeichnis- und Dateinamen nicht mehr als 8 Buchstaben umfassen (von den Dateiendungen abgesehen).

In diesem Zusammenhang ist auch von Interesse, wie Daten und Funktionen aus R im ASCII-Format abgespeichert werden können (dies ist beispielsweise hilfreich, um Daten/Funktionen nach Hause zu ``transportieren''). Mit dem Befehl sink(file="...",appart) wird bewirkt, daß die Ausgabe der nachfolgenden Befehlsergebnisse nicht auf dem Bildschirm, sondern in der in Klammern genannten Datei im ASCII-Format erfolgt. Ist appart=F, werden in der genannten Datei eventuell bereits vorhandene Daten nicht überschrieben (die neuen Daten werden hinten angehängt), ist die Option T, wird die Datei komplett mit den neuen Daten überschrieben. Möchte man beispielsweise das Objekt eis auf einer Diskette in einer Datei mit dem Namen `Eisdat.txt' abspeichern, geschieht das mit der Befehlsfolge

> sink(" A:\\Eisdat.txt")
> eis
> sink()
>

Mit dem letzten Befehl wird bewirkt, daß die Ausgabe der folgenden Befehlsergebnisse nicht mehr in der genannten Datei, sondern wieder auf dem Bildschirm erfolgt. Ebenso ist es mit derselben Vorgehensweise möglich, R-Funktionen (siehe Abschnitt 5) abzuspeichern. Wenn solche Funktionen wieder in R eingelesen werden sollen, kann allerdings nicht der Befehl scan(...) verwendet werden, sondern der entsprechende Befehl heißt source(file="..."), wobei file durch die Pfadangabe der einzulesenden Datei ersetzt werden muß.

4  Arbeiten mit R-Objekten

In dem folgenden Abschnitt soll die grundsätzliche Vorgehensweise von R beim Ausführen von Rechenoperationen an R-Objekten erläutert werden. Hierbei ist ein wesentlicher Punkt zu beachten: R führt die Operationen immer komponentenweise aus. Dies sollte vor allem beim Arbeiten mit Matrizen bedacht werden. Zur Verdeutlichung ein Beispiel: Verbindet man zwei Vektoren mit einem Summenzeichen, werden die einzelnen Komponenten der Vektoren summiert und als neuer Vektor ausgegeben. Daher müssen die jeweiligen Dimensionen der zu addierenden Vektoren übereinstimmen:

> vek1<-c(1,2,3)
> vek2<-c(4,5,6)
> vek1+vek2
[1] 5 7 9
>

Genauso verhält es sich bei der Multiplikation zweier Vektoren (es sei angenommen, daß die oben definierten Vektoren vek1 und vek2 bereits existieren):

> vek1*vek2
[1] 4 10 18
>

R bildet also an dieser Stelle nicht das Skalarprodukt dieser beiden Vektoren, sondern multipliziert auch hier komponentenweise. Analoges gilt für das Arbeiten mit Matrizen:

>mat1<-matrix(c(1,2,3,4),ncol=2)
>mat2<-matrix(c(5,6,7,8),ncol=2)
>mat1*mat2
[,1][,2]
[1,]521
[2,]1232

>

Soll eine Matrizenmultiplikation ausgeführt (oder das Skalarprodukt zweier Vektoren gebildet) werden, muß dies explizit durch den Befehl %*% gekennzeichnet werden:

>mat1%*%mat2
[,1][,2]
[1,]2331
[2,]3446
>

In diesem Zusammenhang sollen zwei weitere, für das Arbeiten mit Matrizen wesentliche Befehle genannt werden: t(...) und solve(...). Mit dem Befehl t(...) wird die transponierte Matrix berechnet (angenommen, die oben verwendete Matrix mat1 ist bereits vorhanden):

>t(mat1)
[,1][,2]
[1,]12
[2,]34
>

Mit dem Befehl solve(...) kann (u.a.) die Inverse einer Matrix berechnet werden:

>solve(mat1)
[,1][,2]
[1,]-21.5
[2,]1-0.5
>

In dem letzten Teil dieses Abschnitts wird erläutert, wie man auf einzelne Elemente von Vektoren und Matrizen direkt zugreifen kann. Zu diesem Zweck wird der Ausdruck ...[...] verwendet. In den eckigen Klammern wird näher spezifiziert, welches Element angesprochen wird. Beispiel:

>vektor<-c(4,5,6,7,8,9)
>vektor[3]
[1] 6
>

Soll ein Element des Vektors nicht genannt werden, so wird das durch ein Minus-Zeichen in den eckigen Klammern kenntlich gemacht:

>vektor<-c(4,5,6,7,8,9)
>vektor[-3]
[1] 4 5 7 8 9
>

Beim Ansprechen eines einzelnen Elementes aus einer Matrix müssen zwei Dimensionen genannt werden, um das Element genau zu spezifizieren: Die gewünschte Zeile und die gewünschte Spalte. Dies geschieht, indem in den eckigen Klammern zunächst die Zeile genannt wird und nachfolgend die Spalte (durch Komma getrennt):

>mat1<-matrix(c(1,2,3,4),ncol=2)
>mat1[2,1]
[1] 2
>

Soll eine ganze Zeile einer Matrix angesprochen werden, so wird auf die Angabe der Spalte verzichtet und die Eingabe der Spezifikation mit dem Komma abgschlossen:

>mat1<-matrix(c(1,2,3,4),ncol=2)
>mat1[2,]
[1] 2 4
>

Analoges gilt für das Ansprechen einer Spalte.

Die hier am Beispiel von Vektoren und Matrizen ausgeführten Rechenoperationen gelten in den Grundzügen auch für das Arbeiten mit Data Frames und Arrays.

5  Funktionen

5.1  Begriffsabgrenzung

Funktionen (oder auch Programme) stellen eine definierte Abfolge von Befehlen dar. Sie vereinfachen den Umgang mit R, indem sie den Dialogablauf rationalisieren: Ist man beispielweise an der Berechnung der Spaltensummen einer Matrix interessiert und möchte die berechneten Summen in einem Vektor abspeichern, so wäre es zu umständlich, für jede Spalte die Summe zu berechnen und anschließend das Ergebnis dem zuvor definierten Vektor zuzuweisen. Statt dessen wird einfach eine Funktion verwendet, die die erforderlichen Befehle hintereinander ausführt.

Grundsätzlich bestehen Funktionen aus einem Eingabe-, einem Verarbeitungs- und einem Ausgabeteil. Übertragen auf das Beispiel benötigt man demnach eine Funktion, die als Eingabe eine Matrix beinhalten muß, in ihrem Verarbeitungsteil den Vektor der Spaltensummen berechnet und diesen Vektor als Ausgabe zur Verfügung stellt.

Man kann Funktionen unterscheiden, die in R bereits vorhanden sind und Funktionen, die vom Anwender selbst programmiert werden. Bei den erstgenannten Funktionen handelt es sich um Funktionen, die ``häufig'' benötigt werden. Die wichtigsten dieser Funktionen bilden den Gegenstand des folgenden Abschnitts 5.2.2 Die selbst programmierten Funktionen werden für Problemstellungen benötigt, für die keine Standardfunktionen von R zur Verfügung stehen. In Abschnitt 5.3 wird dargestellt, wie man solche Funktionen für individuelle Problemstellungen programmieren kann.

Vor der Erläuterung der einzelnen Funktionen werden an dieser Stelle die allgemeinen Regeln erläutert, die bei dem Umgang mit Funktionen zu beachten sind. Verdeutlicht werden diese an der Funktion matrix(...), die bereits in Abschnitt 3.2 dargestellt wurde: Zunächst ist die Bezeichnung der auszuführenden Funktion einzutippen. Im Beispiel also matrix. Im Anschluß an die Funktionsbezeichnung ist der Eingabeteil der Funktion in runden Klammern zu definieren. Der Eingabeteil besteht aus einer bestimmten Anzahl von Argumenten, denen Werte zuzuordnen sind. Die Argumente der Funktion matrix sind data, ncol, nrow und byrow. Diese sind in den runden Klammern, in dieser Reihenfolge und durch ein Komma getrennt zu spezifizieren. Beispielsweise ist also matrix(1:4,2,2,F) einzugeben. Für andere Funktionen ist die Reihenfolge zu verwenden, die in der Hilfe der entsprechenden Funktion angegeben ist. Zwei Dinge sind noch zu erwähnen: Zum einen kann auf die Einhaltung der Reihenfolge verzichtet werden, wenn die Bezeichnungen der Argumente in den Eingabeteil aufgenommen werden. So liefert zum Beispiel die Eingabe von matrix(byrow=F,ncol=2,data=1:4,nrow=2) dieselbe Matrix wie oben. Zum anderen ist zu bemerken, daß es Argumente gibt, die nicht definiert werden müssen. Solche sogenannten optionalen Argumente können definiert werden. Wird auf die Definition eines optionalen Arguments verzichtet, wird ihm automatisch ein Default-Wert von R zugeordnet. Ein solches Argument der Funktion matrix(...) ist beispielsweise byrow, dem automatisch der Default-Wert F zugeordnet wird, wenn auf dessen explizite Definition verzichtet wird. Auch die Eingabe von matrix(1:4,2,2) liefert also dieselbe Matrix wie oben.

5.2  Einige in R integrierte Funktionen

5.2.1  Funktionen zur Erzeugung von Vektoren

Erzeugung eines Vektors mit beliebigen Elementen
Zur Erzeugung eines Vektors mit einzeln zu spezifizierenden Komponenten wird die Funktion
c(...) verwendet. Diese Funktion wurde bereits erläutert (siehe Abschnitt 3.2), so daß hier nicht mehr darauf eingegangen wird.

Erzeugung eines Vektors der Länge n mit identischen Elementen
Ein Vektor mit bestimmter Länge n, der nur identische Elemente enthält, ist mit der Funktion
rep(x,times,length) zu erzeugen. Hier werden die beiden ersten Argumente dieser Funktion erläutert: Das erste Argument beschreibt die zu replizierenden Vektorelemente, und das zweite Argument (times) dient zur Definition der Anzahl von Wiederholungen. Um beispielsweise den Vektor (5,5,5)¢ zu generieren, ist die Funktion rep(5,3) auszuführen:

>rep(5,3)
[1] 5 5 5
>

Erzeugung eines Vektors mit ganzen Zahlen von a bis b
Wenn man eine Zahlenreihe von einem Startwert a bis zu einem Endwert b aus ganzen Zahlen erzeugen möchte, so ist der Befehl a:b zu verwenden. Zum Beispiel liefert die Eingabe 3:5 den Vektor (3,4,5)¢:

>3:5
[1] 3 4 5
>

Erzeugung eines Vektors von a bis b mit definierter Länge oder definierter Schrittweite
Der Befehl seq(a,b,length,by) kann entweder zur Erzeugung eines Vektors mit definierter Länge oder definierter Schrittweite verwendet werden. Um z.B. einen Vektor von a = 3 bis b = 4 mit 3 Elementen zu erzeugen, ist die Funktion seq(3,4,length=3) auszuführen. Das Ergebnis ist der Vektor (3,3.5,4)¢:

>seq(3,4,length=3)
[1] 3.0 3.5 4.0
>

Möchte man statt der Länge eine Schrittweite definieren, so ist hingegen das Argument by zu spezifizieren. Zum Beispiel liefert die Ausführung der Funktion seq(3,3.2,by=0.1) den Vektor (3,3.1,3.2)¢:

>seq(3,3.2,by=0.1)
[1] 3.0 3.1 3.2
>

5.2.2  Funktionen zur Berechnung von Kenngrößen eines Datensatzes

Berechnung des Mittelwertes
Die Funktion, die den Mittelwert eines Vektors oder einer Matrix berechnet, heißt mean(x). Soll beispielsweise der Mittelwert des Vektors (3,5)¢ berechnet werden, so liefert mean(c(3,5)) das Ergebnis, also den Wert 4:

>mean(c(3,5))
[1] 4
>

Neben dem einfachen Mittelwert ist es möglich, mit der Funktion weighted.mean(...) einen gewichteten Durchschnitt zu berechnen. Weitere Informationen zu dieser Funktion sind der Hilfe zu entnehmen.

Berechnung der Varianz
Die Varianz eines Datensatzes wird mit der Funktion var(x) berechnet. Die Eingabe
var(c(3,5)) liefert als Ergebnis den Wert 2:

>var(c(3,5))
[1] 2
>

Wie man an diesem Beispiel leicht erkennt, wird mit R also der erwartungstreue Schätzer der Varianz S* = åi(xi-[`x])2/(n-1) bestimmt. Um S = åi(xi-[`x])2/n , also den Schätzer mit dem kleineren mittleren quadratischen Fehler zu berechnen, ist das Ergebnis der Funktion var mit
(n-1)/n zu multiplizieren. Im Beispiel muß also var(c(3,5))*1/2 berechnet werden. Das Ergebnis ist dann 1:

>var(c(3,5))*1/2
[1] 1
>

Berechnung von Minimum und Maximum
Die Befehle min(x) bzw. max(x) dienen zur Bestimmung des Minimums bzw. Maximums eines Datensatzes. Demnach liefert min(c(3,5)) den Wert 3 undmax(c(3,5)) den Wert 5.

>min(c(3,5))
[1] 3

>max(c(3,5))
[1] 5
>

Berechnung von Kovarianz und Korrelation
Um die Kovarianz zweier Vektoren zu berechnen, wird die Funktion cov(x,y) verwendet. Zur Ausführung der Funktion müssen zwei Vektoren als Argumente definiert werden. Die Kovarianz der Vektoren (3,4,5)¢ und (3,4,6)¢ beträgt beispielsweise 1.5:

>cov(c(3,4,5),c(3,4,6))
[1] 1.5
>

Die Berechnung der Korrelation erfolgt analog zur Berechnung der Kovarianz mit dem Befehl cor(x,y):

>cor(c(3,4,5),c(3,4,6))
[1] 0.9819805
>

Die Korrelation der Vektoren beträgt also ca. 0.98. Ferner kann in den Befehlen als einziges Argument eine Matrix definiert werden. Dann berechnet R die Kovarianz- bzw. Korrelationsmatrix der Spaltenvektoren dieser Matrix.

5.2.3  Funktionen für Verteilungen

Die Funktionen für Verteilungen werden in vier Gruppen unterteilt:

  1. Funktionen zur Berechnung des Funktionswertes einer Dichte- bzw. Wahrscheinlichkeitsfunktion.
  2. Funktionen zur Berechnung des Funktionswertes einer Verteilungsfunktion.
  3. Funktionen zur Berechnung von Quantilen einer Verteilung.
  4. Funktionen zur Erzeugung von Zufallszahlen einer Verteilung.

Diese Funktionen existieren für zahlreiche Verteilungen. Man kann sich vorstellen, daß sie sich aus zwei Teilen zusammensetzen: Der erste Buchstabe kennzeichnet die Funktionsgruppe. Beispielsweise wird ein r verwendet, um Zufallszahlen zu erzeugen. Direkt im Anschluß, d.h. ohne Leerzeichen, folgt die Kennzeichnung der Verteilung. Beispielsweise wird pois verwendet, um eine Poissonverteilung zu kennzeichnen. Die zusammengesetzte Funktionsbezeichnung lautet demnach rpois.

Die Funktionsgruppen werden hier beispielhaft an der Normalverteilung veranschaulicht, da die Verwendung der Funktionen bei anderen Verteilungen analog erfolgt (mit Ausnahme der anzugebenden Parameter; Informationen zu anderen Verteilungen sind in der Hilfe erhältlich).

Berechnung des Funktionswertes einer Dichtefunktion
Die Berechnung des Funktionswertes der Dichtefunktion einer Normalverteilung erfolgt mit der Funktion pnorm(q,mean,sd). Dabei sind neben dem Abszissenwert q der Erwartungswert mean und die Standardabweichung sd festzulegen. Werden m und s nicht definiert, so gilt m = 0 und
s = 1 (diese Default-Werte gelten auch für die übrigen Funktionen zur Normalverteilung). Um zum Beispiel den Wert der Dichtefunktion an der Stelle 1.644854 einer Standardnormalverteilung zu berechnen, ist folgende Funktion auszuführen:

>dnorm(1.644854,0,1)
[1] 0.1031356
>

Diese Funktion wird beispielsweise für graphische Darstellungen der Dichtefunktion verwendet (siehe Abschnitt 6).

Berechnung des Funktionswertes einer Verteilungsfunktion
Der Wert der Verteilungsfunktion an der Stelle x gibt die Wahrscheinlichkeit an, daß ein Wert kleiner oder gleich x realisiert wird. Die Wahrscheinlichkeit für eine Realisation kleiner/gleich 1.644854 beträgt bei einer Standardnormalverteilung 0.95. Mit R ist dieser Wert so zu berechnen:

>pnorm(1.644854,0,1)
[1] 0.95
>

Berechnung von Quantilen

Diese Werte geben die Ausprägung x an, die mit definierter Wahrscheinlichkeit nicht überschritten wird. Möchte man beispielsweise wissen, welcher Wert bei einer Standardnormalverteilung mit einer Wahrscheinlichkeit von 0.95 nicht überschritten wird, liefert qnorm(0.95,0,1) das richtige Ergebnis:

>qnorm(0.95,0,1)
[1] 1.644854
>

Erzeugung von Zufallszahlen einer Verteilung
Um Zufallszahlen aus einer Standardnormalverteilung zu erzeugen, ist die Funktion
rnorm(n,mean,sd) zu verwenden. Es ist dabei notwendig, die Anzahl n der zu erzeugenden Zufallszahlen anzugeben. Die Erzeugung von drei Zufallszahlen einer Standardnormalverteilung könnte beispielsweise zu dem folgenden Ergebnis führen:

>rnorm(3,0,1)
[1] 0.9806575 -0.2677341 0.4483162
>

5.2.4  Weitere nützliche Funktionen

Berechnung der Länge eines Datensatzes
Gelegentlich möchte man die Anzahl der Elemente eines Vektors oder einer Matrix bestimmen. Dazu verwendet man die Funktion length(x). Beispielsweise enthält der Vektor (3,4,5)¢ drei Elemente:

>length(c(3,4,5))
[1] 3
>

Sortieren eines Datensatzes
Um die Elemente eines Vektors oder einer Matrix in sortierter Reihenfolge zu erhalten, wird die Funktion sort(x) eingesetzt. Sortiert man zum Beispiel den Vektor (4,5,3)¢, so erhält man als sortierten Vektor (3,4,5)¢:

>sort(c(4,5,3))
[1] 3 4 5
>

Summe/Produkt eines Datensatzes
Zur Berechnung der Summe bzw. des Produkts werden die Funktionen sum(...) bzw.
prod(...) verwendet. Um beispielsweise den Wert 12 als Summe der Vektorelemente des Vektors (3,4,5)¢ zu berechnen, ist die Ausführung der Funktion sum(c(3,4,5)) erforderlich:

>sum(c(3,4,5))
[1] 12
>

Analog dazu liefert prod(c(3,4,5)) den Wert 60:

>prod(c(3,4,5))
[1] 60
>

Erzeugen von Stichproben aus individuell festzulegenden Grundgesamtheiten
Möchte man eine Stichprobe nicht aus einer bestimmten Verteilung einer Zufallsvariablen ziehen, sondern die Grundgesamtheit individuell festlegen, hilft der Befehl sample(x,size,replace,prob). Hierbei wird mit x der Vektor von möglichen Werten in der Grundgesamtheit vorgegeben, size ist die Stichprobengröße und mit replace wird spezifiziert, ob die Stichprobe mit (replace=T) oder ohne Zurücklegen (replace=F, Default-Wert) gezogen wird. Mit prob wird dem Vektor der möglichen Werte ein Vektor der zu den einzelnen Werten gehörenden Wahrscheinlichkeiten zugeordnet. Fehlt die Angabe für prob, wird für alle Werte die gleiche Wahrscheinlichkeit angenommen. Möchte man beispielsweise einen dreimaligen Würfelwurf simulieren, kann dies mit R folgendermaßen geschehen:

>sample(1:6,3,replace=T)
[1] 2 6 1
>

5.3  Programmierung von Funktionen

Die im letzten Abschnitt behandelten Funktionen sind in R bereits enthalten. Sie stellen nur einen sehr kleinen Ausschnitt aus den vorhanden Funktionen dar, wie man sich mit einem Blick in die Hilfe leicht klar macht. Dennoch gibt es häufig individuelle Problemstellungen, für die in R keine entsprechenden Funktionen zur Verfügung stehen. Es wird deshalb in diesem Abschnitt gezeigt, wie man in solchen Situationen eigene Funktionen programmieren kann, um das Problem zu lösen.

Im letzten Abschnitt wurden zwei Standardfunktionen zur Berechnung eines Mittelwertes vorgestellt: R stellt Funktionen zur Berechnung eines einfachen und eines gewichteten arithmetischen Mittels zur Verfügung. Angenommen man möchte den geometrischen Mittelwert Pixi1/n eines Vektors bestimmen. Für diesen Fall steht keine Standardfunktion von R zur Verfügung. Im folgenden wird gezeigt, wie man für diese Problemstellung eine einfache Funktion programmieren kann.

Zunächst muß man einen Namen für die Funktion wählen. Es ist sinnvoll, einen Namen zu verwenden, der inhaltlich die Funktion charakterisiert. Im Beispiel wird der Name geo.mean verwendet.

Nach der Wahl eines Namens muß man diesen als Funktionsobjekt in R definieren. Dies erfolgt durch den folgenden Befehl:

>geo.mean<-function(){}
>

Nach der Eingabe des Befehls, liegt in R ein Objekt der Art `Funktion' mit dem Namen geo.mean vor. Allerdings besitzt dieses Funktion noch keinerlei Verarbeitungslogik. Diese ist in einem nächsten Schritt festzulegen. Dazu muß zunächst ein Editor mit dem Befehl fix(Funktion) geöffnet werden:

>fix(geo.mean)
>

Der nach Eingabe des Befehls auf dem Bildschirm erscheinende Editor dient zur Programmierung der Funktion, d.h. in diesem Fenster wird die entsprechende Befehlsfolge eingegeben. Die Berechnung des geometrischen Mittelwerts eines Vektors könnte wie folgt programmiert werden:

function (x)
{
n<-length(x)
mittelwert<-prod(x)^(1/n)
return (mittelwert)
}

Anhand dieser einfachen Funktion werden nun die allgemeinen Regeln der Programmierung mit R erläutert: Hinter dem Ausdruck function werden in runden Klammern die Argumente der Funktion beschrieben. Dieser Eingabeteil der Funktion ist im Beispiel ein Vektor, der mit dem Variablennamen x bezeichnet wurde. Wenn also die Funktion später verwendet wird, um beispielsweise das geometrische Mittel des Vektors (2,8)¢ zu berechnen, ist die Funktion wie folgt auszuführen:

>geo.mean(c(2,8))
[1] 4
>

Nach dem Eingabeteil folgt der Verarbeitungsteil in geschweiften Klammern. Im Beispiel wird zunächst die Länge des Vektors der Variablen n zugewiesen. Anschließend wird das geometrische Mittel der Variablen mittelwert durch die entsprechende Rechenoperation zugewiesen. Danach folgt der Ausgabeteil der Funktion, der ebenfalls innerhalb der geschweiften Klammern zu programmieren ist. Hier erfolgt durch den Befehl return(mittelwert) die Ausgabe des Mittelwerts auf dem Bildschirm.

Nach der vollständigen Erfassung des Funktionstextes ist der Editor zu schließen, indem entweder der Menüpunkt `Datei ® Schließen' gewählt wird oder auf das ` ×' am rechten, oberen Rand des Editors geklickt wird. Bevor der Editor geschlossen wird, fragt R, ob die Änderungen gespeichert werden sollen. Diese Frage ist mit `ja' zu beantworten (es sei denn, die Änderungen sollen ausnahmsweise verworfen werden). Nachdem der Editor geschlossen worden ist, befindet man sich wieder auf der R-Oberfläche, und die Funktion geo.mean kann verwendet werden.

Abschließend hier noch zwei Hinweise, die bei der Programmierung einer Funktion hilfreich sind: Beim Schließen des Editors überprüft R die formale Korrektheit der Funktion (beispielsweise wird überprüft, ob alle Klammern richtig gesetzt worden sind). Wenn dabei ein Fehler auftritt, erscheint eine Fehlermeldung auf der Oberfläche von R, die einen Hinweis auf die Art und den Ort (Angabe durch eine Zeilennummer, die sich auf den Text im Editor bezieht) des Fehlers enthält. Dabei ist zu bemerken, daß R den Funktionstext im Falle eines Fehlers nicht speichert, d.h. bei einem erneuten Aufruf des Editors mit dem Befehl fix(geo.mean) erscheint der Funktionstext ohne die Änderungen der letzten Bearbeitung. Um dies zu umgehen, d.h. die fehlerhafte Funktion inkl. der letzten Änderungen im Editor zu bearbeiten, ist der Befehl edit() auszuführen:

>geo.mean<-edit()
>

Ferner kommt es vor, daß man beim Arbeiten mit der programmierten Funktion und bereits von R gespeicherten logische Fehler bemerkt oder daß der Funktionstext nachträglich erweitert werden muß. Für diesen Fall wird einfach erneut der Befehl fix ausgeführt und anschließend der Funktionstext im erscheinenden Editor bearbeitet:

>fix(geo.mean)
>

6  Graphiken

In der Statistik ist der Einsatz von graphischen Mitteln sehr wichtig. Mit Hilfe einer graphischen Darstellung ist es möglich, einen ersten Überblick über die zu analysierenden Daten zu bekommen; wichtige Dienste leisten solche Darstellungen aber auch bei der Überprüfung, ob ein eventuell angepaßtes Modell die Daten auch adäquat beschreibt. Im folgenden werden die Grundzüge einiger Graphikbefehle erläutert - möchte man die von R in Verbindung mit den einzelnen Funktionen vorgegebenen Standardparameter abändern, sei auf die Hilfefunktion verwiesen. Allgemeine Hinweise zur Gestaltung und Veränderung von graphischen Darstellungen findet man in der Hilfefunktion zu dem Befehl par(...). Ein Beispiel zur Anwendung dieses Befehls findet sich bei Vorstellung des Befehls plot(...) in Abschnitt 6.3.

6.1  Histogramme

Angenommen, man möchte fünfzig Realisationen einer standardnormalverteilten Zufallsvariablen erzeugen und das Ergebnis unter dem Namen normal abspeichern. Nachfolgend möchte man sich ein Histogramm des Vektors normal mit dem Befehl hist(...) anschauen. Die folgende Befehlsfolge führt zu dem richtigen Ergebnis:

>normal<-rnorm(50,0,1)
>hist(normal)
>

Es wird automatisch ein Graphikfenster eröffnet, in dem das Histogramm erscheint. Bei der Eingabe neuer Befehle muß darauf geachtet werden, daß das Kommandofenster aktiv ist - dies wird erreicht, indem letzteres angeklickt wird, so daß das zuletzt verwendete Graphikfenster deaktiviert wird. Wenn das Histogramm individueller gestaltet werden soll, kann dieses durch die Eingabe spezifischer Optionen geschehen. Mehr dazu findet sich in der Hilfefunktion.

6.2  Boxplots

Eine häufig verwendete Darstellungsform ist die der Boxplots. Hierbei wird auf die Quantile einer Datenmenge abgestellt. Möchte man einen Boxplot des oben erstellten Vektors normal erzeugen, so geschieht das mit dem Befehl

>boxplot(normal)
>

Auch hier gilt wieder der Verweis auf die Hilfefunktion, wenn der Boxplot individuell gestaltet werden soll.

6.3  Allgemeine Plots

Mit dem Befehl plot(...) ist es möglich, zwei (gleichlange) Vektoren gegeneinander zu plotten. Hierbei wird als erstes Argument der auf der Abszisse abzutragende Vektor und als zweites Argument der auf der Ordinate abzutragende Vektor eingegeben. Einige andere Argumente des Plot-Befehls werden im folgenden genannt. Möchte man beispielsweise die Funktionswerte der Geraden y = 3x+2 über dem Intervall [1,3] in Schritten von 0.2 berechnen und plotten, lautet die Befehlsfolge hierzu:

>x<-seq(1,3,by=0.2)
>y<-3*x+2
>plot(x,y)
>

Möchte man, daß die Punkte in der Graphik verbunden werden, so gibt man als Option
type="l" ein:

>x<-seq(1,3,by=0.2)
>y<-3*x+2
>plot(x,y,type="l")
>

Oftmals möchte man mehrere Graphiken zugleich betrachten und vergleichen. Mit dem Befehl par(mfrow=c(...)) ist es möglich, das Graphikfenster aufzuteilen, wobei durch den Vektor
c(...) die Anzahl der Zeilen und Spalten des Fensters bestimmt werden. Möchte man Polynome nullten, ersten, zweiten und dritten Grades gleichzeitig betrachten, führt folgende Befehlsfolge zum Ziel:

>x<-seq(1,3,by=0.2)
>y1<-rep(3,times=length(x))
>y2<-3+x
>y3<-3+x+2*x^2
>y4<-3+x+0.5*x^2+0.25*x^3
>par(mfrow=c(2,2))
>plot(x,y1,type="l")
>plot(x,y2,type="l")
>plot(x,y3,type="l")
>plot(x,y4,type="l")
>

Soll die Unterteilung des Fensters für eine andere Graphik aufgehoben werden, das Bild also insgesamt nur noch aus einer Zeile und einer Spalte bestehen, stellt der Befehl
par(mfrow=c(1,1)) den ursprünglichen Zustand wieder her.

Weiterhin gibt es noch viele andere Optionen, um Graphiken den individuellen Wünschen anzupassen. Näheres hierzu findet man - wie bereits erwähnt - in den Hilfen zu den Funktionen plot(...) und par(...).

Ein Beispiel für einen Plot direkt aus dem statistischen Bereich ist der Plot der Dichte einer Standardnormalverteilung. Der erste Schritt ist in diesem Zusammenhang die Berechnung der Funktionswerte (vgl. Abschnitt 5.2.3) über dem betrachteten Intervall (hier -4 bis 4). Danach kann die gewünschte Dichte geplottet werden.

>x<-seq(-4,4,by=0.01)
>y<-dnorm(x,0,1)
>plot(x,y,type="l")
>

Einige der hier verwendeten Graphikbefehle und die daraus resultierenden Graphiken sind auf der Titelseite wiederzuerkennen.

7  Installationsanleitung

Die zur Installation von R benötigten Dateien können alle frei aus dem Internet heruntergeladen werden. Diese Daten befinden sich unter der folgenden Adresse:

a) Für die Windows-Version:
http://www.ci.tuwien.ac.at/R/bin/windows/windows-NT/base
b) Für die Linux-Version:
http://www.ci.tuwien.ac.at/R/bin/linux/

Im folgenden werden die Schritte erläutert, die unternommen werden müssen, um das Basis-Paket und Zusatzpakete in der Windows-Version zu installieren. Für die Installation in Unix sei auf die Internetseite `http://www.ci.tuwien.ac.at/' verwiesen, auf der unter `R& CRAN', `Contributed Extensions', `R Frequently Asked Questions List' unter dem Punkt 2.5.1 Installationshinweise gegeben werden.

7.1  Installation des Basis-Paketes

  1. Alle Dateien (insgesamt 11 für die 99er-Version) auf ein temporäres Verzeichnis der Festplatte kopieren (dies wird gemacht, indem, angefangen mit der Datei rw0990b1.zip, die gewünschte Datei angeklickt wird und diese dann in dem gewünschten Verzeichnis abgespeichert wird).
  2. Ausführen von `rwinst.exe'.
  3. Auswahl der zu installierenden R-Version (der Default-Wert ist die neueste Version von R, beispielsweise rw0990).
  4. Eingabe des Quellverzeichnisses der R-Dateien. Hier muß das temporäre Verzeichnis angegeben werden, in das die R-Dateien kopiert wurden (siehe Punkt 1).
  5. Eingabe des Installationsverzeichnisses (normalerweise ist das C:\ Programme\R).
  6. Anklicken des `Next-Button'.
  7. Auswahl aller Optionen durch Mouseklick, danach erneutes Anklicken des `Next-Button'.
  8. Warten, bis die Installation vollendet ist (das Ende wird angezeigt).
  9. Anklicken des `Finish-Button'.
  10. Durch Ausführen der Datei `Rgui.exe' in dem Unterverzeichnis`rw0990\bin' von R wird R gestartet.

7.2  Installation von Zusatzpaketen

Solche Zusatzpakete werden benötigt, um Zugriff auf in dem Basispaket nicht enthaltene Funktionen zu bekommen, beispielsweise ist die Funktion zur Berechnung der Autokorrelationsfunktion in dem Basispaket nicht enthalten, aber in einem Zusatzpaket.

  1. Kopieren der Zip-Datei des gewünschten Paketes in ein temporäres Verzeichnis (die Pakete findet man auf der Seitehttp://www.ci.tuwien.ac.at/R/bin/windows/windows-NT/contrib).
  2. Ausführen der Datei `rwinst.exe' (von dem Basis-Paket, siehe Abschnitt 7.1, Punkt 2).
  3. Auswahl von `an add-on package'.
  4. Eingabe des Quellverzeichnisses (das temporäre Verzeichnis, siehe Punkt 1).
  5. Eingabe des Installationsverzeichnisses (Anmerkung: Dies muß derselbe Pfad sein, auf dem auch R installiert wurde (PLUS Versionsverzeichnis. Beispiel: C:\Programme\R\rw0990).
  6. Anklicken des `Next-Button'.
  7. Auswahl des zu installierenden Paketes aus der Liste und erneutes Anklicken des `Next-Button'.
  8. Warten, bis die Installation abgeschlossen ist.
  9. Anklicken des `Finish-Button'.
  10. Starten von `R'.
  11. Eingabe der folgenden Befehle:
    a) link.html.help(package name)
    b) library(package name).

Die Funktionen des neuen Paketes sollten nun verfügbar sein.

Alternativ kann man das entsprechende Paket auch mit einem Entpacker in das `library'-Unterverzeichnis von R direkt entpacken und dann die ab 10 beschriebenen Schritte durchführen.

HINWEIS: Für die Unix-Version finden sich die zu installierenden Pakete auf der Seite
http://www.ci.tuwien.ac.at/R/src/contrib/PACKAGES.html.


Footnotes:

1Beispielsweise kann mit Hilfe solcher Objektarten ein Objekt `Kunde' erstellt werden, unter dem Eigenschaften wie Name, Vorname, Anschrift... zusammengefaßt werden können.

2 Einige solcher Funktionen (beispielsweise solve(matrix) zur Berechnung der Inversen einer Matrix) sind bereits dargestellt worden, ohne daß explizit auf den Begriff der Funktion eingegangen wurde (siehe Abschnitt4).


File translated from TEX by TTH, version 2.65.
On 11 May 2000, 10:00.