|
|
Thema
|
Tipp oder Trick...
|
|
|
Argumente einer Funktion
|
Sind Ihnen die Argumente zum Funktionsaufruf nicht mehr geläufig und Sie möchten sich auch nicht durch die Hilfefunktion zur Funktion arbeiten, hilft das Argument args(Funktion) weiter. Die Argumente zur Funktion kontingenz() (Kontingenzanalyse) über die Funktion args() aufgerufen, sind folgende:
Oder für die Funktion rnorm() werden folgende Argumente benötigt:
|
|
|
“...”-Argument
|
Wenn Sie eigene Funktionen schreiben und in dieser Funktion z. B. die argumentreiche Funktion plot() verwenden, besteht bei Ihnen sicher der Wunsch nicht alle für plot() nötige Argumente formal anzugeben. Um dennoch die Möglichkeiten von plot() nutzen zu können, bietet R das ...-Punkte-Argument an.
D. h., Sie können über das ...-Punkte-Argument die nötigen Argumente an die plot()-Funktion weiterleiten. Diese Funktionsweise wird am Beispiel der Funktion mean() gezeigt:
Beinhaltet Ihr Datensatz Daten mindestens ein NA (z. B.: 95 94 96 NA 97 93) liefert folgender Funktionsaufruf dreipunkte(Daten) kein brauchbares Ergebnis. Aber durch das ...-Punkte-Argument liefert dieser Aufruf dreipunkte(Daten, na.rm = T) das richtige Ergebnis 95. Das Argument na.rm = T durch die ...-Punkte zur Funktion mean() “durchgeleitet”!
|
|
|
Dateien einlesen
|
Möchten Sie dem Anwender einer Funktion die Auswahl der zu ladenden Datei überlassen, hilft Ihnen die Funktion choose.files() weiter. Wird die Funktion aufgerufen, wird das vom Betriebssystem abhängige Dateiauswahlmenü gezeigt:
Folgenden R-Code könnten Sie in Ihrer Funktion nun nutzen:
Datei <- choose.files(filters = Filters[c("txt", "All"),])
Inhalt <- read.table(Datei, header = T, sep=";")
Durch obige Filtereinstellung (filters), werden nur “.txt”-Dateien angezeigt. Diese Einstellung kann natürlich geändert werden:
Die Variable Datei enthält nach der Auswahl die komplette Pfad-Angabe und nach dem Einlesen der Datei in das Objekt Inhalt könnte die Ausgabe wie folgt aussehen:
Als Variante können Sie auch um z. B. eine Tabellenkalkulationsdatei einzulesen schreiben:
> Daten <- read.csv2(choose.files(), ...)
Die ... sind Platzhalter für die read.csv2-Funktionsargumente.
|
|
|
Dateien vergleichen
|
Schreiben Sie eigene Funktionen, kann es passieren, dass Sie mehrere “Versionen” dieser Funktion auf Ihrer Festplatte/Server gespeichert haben. Die Gründe können natürlich vielfältig sein, aber der häufigste Grund ist sicher in der “Entwicklungsfolge” zu sehen. Eine Entwicklungsfolge beschreibt den Entwicklungsprozess aus Versuch und Irrtum und der resultierenden Datensicherung.
Um hier nicht den Überblick zu verlieren, kann ein Vergleichsprogramm wie z. B. UltraCompare weiterhelfen. Mit diesem Programm wird der Inhalt von zwei Textdateien dargestellt, verglichen und Unterscheidungen dargestellt:
Sie können dann die unterschiedlichen Inhalte in das linke oder rechte Fenster durch “Knopfdruck” übernehmen.
|
|
|
Datenobjekt-Info
|
Das Paket Hmisc bietet einige nützliche Funktionen an und eine davon ist die Funktion describe(). Über diese Funktion werden Informationen zum R-Datenobjekt, z. B. eines Datensatzes (data.frame()) ausgegeben. Hier ein Beispiel zu einem Datensatz:
Und hier die Information über die Funktion describe():
> describe(Daten)
Daten
5 Variables 9 Observations
-----------------------------------------------------------------------------
Wirkstoff.A
n missing unique Mean
9 0 8 99.17
98.8 98.9 99 99.1 99.2 99.3 99.4 99.5
Frequency 1 1 1 1 1 2 1 1
% 11 11 11 11 11 22 11 11
-----------------------------------------------------------------------------
Wirkstoff.B
n missing unique Mean
9 0 7 97.19
96.9 97 97.1 97.2 97.3 97.4 97.5
Frequency 2 1 1 1 1 2 1
% 22 11 11 11 11 22 11
-----------------------------------------------------------------------------
Wirkstoff.C
n missing unique Mean
9 0 7 95.46
95.1 95.3 95.4 95.5 95.6 95.7 95.8
Frequency 2 1 1 1 2 1 1
% 22 11 11 11 22 11 11
--------------------------------------------------------------------------------
Pruefer
n missing unique
9 0 2
Karl (4, 44%), Peter (5, 56%)
-----------------------------------------------------------------------------
Datum
n missing unique
9 0 9
2008-08-10 2008-08-11 2008-08-12 2008-08-13 2008-08-14 2008-08-15
Frequency 1 1 1 1 1 1
% 11 11 11 11 11 11
2008-08-16 2008-08-17 2008-08-18
Frequency 1 1 1
% 11 11 11
-----------------------------------------------------------------------------
|
|
|
Datenobjekt-Info anlegen
|
Über die Funktion comment() sind Sie in der Lage, einer z. B. kryptischen Variablenbezeichnung einen erklärenden Kommentar anzuheften. Hierzu ein kleines Bespiel:
Der obige Kommentar “Mein Kommentar” wurde dem Objekt x zugeordnet. Lassen Sie sich wie gewohnt den Inhalt von x anzeigen oder verwenden ihn in Berechnungen, merken Sie davon nichts. Sie können sich den Kommentar mit comment(x) oder auch über str() anzeigen lassen:
> comment(x)
[1] "Mein Kommentar"
> str(x)
atomic [1:100] -0.0776 0.7635 0.5122 -0.8217 -0.9334 ...
- attr(*, "comment")= chr "Mein Kommentar"
Die Erweiterung desObjektes x lässt sich auch über die Funktion attributes() zeigen:
|
|
|
Datenbank ODBC
CSV
|
Datenbankanbindung über ODBC und dem Paket RODBC
Die Datenbankanbindung wird exemplarisch am Beispiel einer CSV-Datei (Textdatei aus einer Tabellenkalkulation) beschrieben. Sicher können derartige Dateien nicht als Datenbank gesehen werden, aber die Vorgehensweise über ODBC ist sicher übertragbar auf echte Datenbanken. Bevor unter dem Betriebssystem MS-Windows© auf eine CSV-Datei über ODBC zugegriffen werden kann, muss diese über ODBC-Datenquellen-Adiminstrator mit dem Treiber verknüpft werden. Dazu rufen Sie über die Systemsteuerung die Verwaltung und anschließend Datenquellen (ODBC) auf:
Im Bereich Benutzer_DSN fügen den Datenquellen-Treiber und...
... ordnen die Daten-Datei, hier als Beispiel SPCDaten.csv, zu:
Achten Sie hier auf das Datenbankverzeichnis. Schließen Sie die Datenbankadministration ab und laden in die R-Umgebung das Paket RODBC. Um nun mit der Datenbank zu arbeiten, muss eine Verbindung zur Datenbank aufgebaut werden. Dazu dient die Funktion odbcConnect():
Die Verbindungsdaten werden im Objekt DB gespeichert und zeigt folgenden Inhalt:
Nun sind Sie in der Lage SQL-Anweisungen auf diese Datenbank anzuwenden. Das einfachste dürfte wohl sein zeige mir den Inhalt von SPCDaten.csv:
> sqlQuery(DB, ("select * from SPCDaten.csv"))
Material_Nr Charge Prüflos Merkmalbezeichnung Untere_EG Untere_WG Merkmal
1 4711 A 100100001 Wirkstoff_A 95 96 97.3
2 4711 B 100100002 Wirkstoff_A 95 96 97.1
3 4711 C 100100003 Wirkstoff_A 95 96 97.5
4 4711 E 100100004 Wirkstoff_A 95 96 97.6
5 4711 F 100100005 Wirkstoff_A 95 96 97.2
6 4711 G 100100006 Wirkstoff_A 95 96 97.8
7 4711 H 100100007 Wirkstoff_A 95 96 97.7
8 4711 I 100100008 Wirkstoff_A 95 96 97.6
9 4711 J 100100009 Wirkstoff_A 95 96 97.8
10 4712 A 100100010 Wirkstoff_B 48 49 50.2
11 4712 B 100100011 Wirkstoff_B 48 49 49.7
12 4712 C 100100012 Wirkstoff_B 48 49 50.3
13 4712 E 100100013 Wirkstoff_B 48 49 50.0
14 4712 F 100100014 Wirkstoff_B 48 49 50.1
15 4712 G 100100015 Wirkstoff_B 48 49 49.9
usw.
Sie können jede gültige SQL-Anweisung anwenden, z.b die Selektion der 4711er-Materialien:
> sqlQuery(DB, ("select * from SPCDaten.csv where Material_Nr = 4711"))
Material_Nr Charge Prüflos Merkmalbezeichnung Untere_EG Untere_WG Merkmal
1 4711 A 100100001 Wirkstoff_A 95 96 97.3
2 4711 B 100100002 Wirkstoff_A 95 96 97.1
3 4711 C 100100003 Wirkstoff_A 95 96 97.5
4 4711 E 100100004 Wirkstoff_A 95 96 97.6
5 4711 F 100100005 Wirkstoff_A 95 96 97.2
6 4711 G 100100006 Wirkstoff_A 95 96 97.8
7 4711 H 100100007 Wirkstoff_A 95 96 97.7
8 4711 I 100100008 Wirkstoff_A 95 96 97.6
9 4711 J 100100009 Wirkstoff_A 95 96 97.8
Oder Materialien dessen Merkmals-Wert > 97,5 beträgt:
> sqlQuery(DB, ("select * from SPCDaten.csv where Merkmal > 97.5"))
Material_Nr Charge Prüflos Merkmalbezeichnung Untere_EG Untere_WG Merkmal
1 4711 E 100100004 Wirkstoff_A 95 96 97.6
2 4711 G 100100006 Wirkstoff_A 95 96 97.8
3 4711 H 100100007 Wirkstoff_A 95 96 97.7
4 4711 I 100100008 Wirkstoff_A 95 96 97.6
5 4711 J 100100009 Wirkstoff_A 95 96 97.8
Über Paket-Funktionen können natürlich auch Tabellen geändert und gesichert werden. Schauen Sie sich die Möglichkeiten an....!
|
|
|
Funktionsmodell, Aufruf
|
Ein z. B. lineare Modell wird über den Funktionsaufruf lm(y ~ x) geschätzt. Möchten Sie diesen Aufruf auf beispielsweise folgende Funktion
anwenden, muss die arithmetische Bedeutung im Modell berücksichtigt werden. Ein Aufruf in dieser Form
zeigt folgendes Ergebnis:
Obiges Ergebnis ist sicher nicht das gewünschte Ergebnis.
Durch die Funktion I()wird die arithmetische Bedeutung beibehalten.
|
|
|
“Globale” Variable
|
Möchten Sie eine Variable (Datenstruktur) auch außerhalb einer Funktion dem Anwender zur Verfügung stellen, können Sie dies über das Zuweisungszeichen “<<-” erreichen. Hierbei sollten Sie aber die Eindeutigkeit um nicht in Konflikt mit anderen Objekten zu kommen bedenken. Empfehlen möchte ich Ihnen z. B. folgendes Konstrukt:
Funktion ist die Funktionsbezeichung und GlobaleVariable die Bezeichnung der globalen Variable. Diese Zusammensetzung der globalen Variable stellt eine halbwegs eindeutige Möglichkeit dar.
|
|
|
Grafik, Ausgabe als Datei
|
Möchten Sie die grafische Ausgabe nicht auf den Bildschirm darstellen, sondern als Datei ausgeben, verwenden Sie die Funktionen jpeg(), bmp() oder png():
Die Ausgabedatei befindet sich nun in dem zuvor eingestellten Verzeichnis:
|
|
|
Grafik, Ausgabe mehrere Grafiken in einer Darstellung
NEU!
|
Die simple Frage “Wie können z. B. 2 Grafiken zusammen dargestellt werden?” kann wie folgt beantwortet werden:
> plot(sin,0,2*pi,ylab="")
> plot(cos,0,2*pi,ylab="",col= "red", add=TRUE)
Der Schlüssel ist hier das Argument add=TRUE!
|
|
|
Grafik, Ausgabe mehrere Darstellungen
|
Möchten Sie mehrere Grafiken in einem Grafikfenster ausgeben, können Sie dies über das Argument fig der der Funktion par() erreichen. Mit dem Argument fig werden die Ausgabebereiche des Grafikfensters angesprochen. Folgendes Beispiel soll dies verdeutlichen:
Das Objekt x beinhaltet die darzustellenden Daten. Über par() mit dem Argument fig wird festgelegt, dass unten 35% der Grafikfläche für den Boxplot zur Verfügung gestellt wird. Der Boxplot wird horizontal ausgegeben:
> x <- rnorm(100, 95,1)
> par(fig=c(0,1,0,0.35))
> boxplot(x, horizontal=TRUE)
Über die nächste par()-Funktion werden die restlichen 75% des Grafikfensters zur Ausgabe des Histogramms festgelegt. Das Histogramm wird als Dichtefunktion (prob)mit einer gestrichelten Linie (lines) dargestellt:
> par(fig=c(0,1,.25,1), new = TRUE)
> hist(x, prob=TRUE)
> lines(density(x), lty=2)
|
|
|
Grafik, Streudiagramm und Boxplot
|
Die Grafikfunktion boxplot() verfügt über das Attribut add und damit sind Sie in der Lage, ein Boxplot zur ergänzenden Darstellungen z. B. zu einem Streudiagramm zusätzlich anzuzeigen. Diese Möglichkeit ist eine Variante zu der hier beschriebenen. Beispiel:
> x <- rnorm(100, 10,0.5)
> plot(x)
> boxplot(x,range = 0, add = T, boxwex = 5, col = "grey", at = -1)
Über das Attribut add = T wird der Boxplot zur Grafik addiert, mit dem Attribut boxwex = 5 wird die “Breite” des Plots und über at = -1 wird die Position (ein bisschen ausserhalb der dargestellten Daten) festgelegt:
|
|
|
Grafik, mehrere Histogramme darstellen
NEU!
|
Möchten Sie mehrere Histogramme darstellen, hilft die Funktion multhist() des Paketes plotrix weiter:
> Daten <- list(rnorm(50, mean=3),rnorm(50,mean=5, sd=2),rnorm(50,mean=4))
> multhist(main="3 Histogramme", Daten)
|
|
|
Grafik, Ausgabe Histogramm-Daten
|
Möchten Sie zusätzlich beispielhaft zu einem Histogramm die Anzahl der Beobachtungen in einer Klasse ausgeben, kann als “Anregung” Ihnen sicher folgendes Code-Schnipsel weiterhelfen (Siehe auch hier!):
> x <- rnorm(10000, 0, 1)
> hx <- hist(x, breaks=50, plot=FALSE)
> plot(hx, col=ifelse(abs(hx$breaks) < 1.96, 3, 2), main="Histogramm", xlab="Ihre z-normierte Daten", ylab="Häufigkeit")
> text(hx$mids, hx$counts+2, label=c(hx$counts), pos = 3)
Die Anzahl der Klasseninhalte wird über die Funktion text() ausgegeben. Dabei bestimmt der Parameter pos die Textausgabeposition. Experimentieren Sie mit diesem Parameter und schauen Sie auch in die Hilfe zur Funktion text().
|
|
|
Grafik, Bereiche unterschiedlich “einfärben”
|
Es kann hilfreich sein, z. B. in einem Histogramm Bereiche unterschiedlich farblich darzustellen. Als “Anregung” soll Ihnen folgendes Code-Schnipsel dienen:
> x <- rnorm(10000, 0, 1)
> hx <- hist(x, breaks=50, plot=FALSE)
> plot(hx, col=ifelse(abs(hx$breaks) < 1.96, 3, 2), main="Histogramm", xlab="Ihre z-normierte Daten", ylab="Häufigkeit")
Interessant ist hier die ifelse()-Funktionalität! Ist der Absolutwert kleiner als 1,96 wird der Farbwert 3 für grün (= yes) und wenn größer als 1,96 wird der Farbwert 2 für rot (= no) verwendet.
|
|
|
Grafik, Bereich unter einem Polygonzug einfärben
|
Besteht der Wunsch, die Fläche unter z. B. einem Polygonzug einzufärben, können Sie dieses über die Funktion polygon() erreichen:
> x <- 1:50
> y <- rnorm(50)
> plot(x,y)
> lines(x,y)
> polygon(cbind(c(min(x),x,max(x)),c(min(y),y,min(y))), col="grey")
Hier das Resultat:
|
|
|
Grafik, Farben
|
Möchten z. B. Grafiken mit unterschiedlichen Farben erzeugen, stellen Sie sich vielleicht die Frage, welche vordefinierte Farben R Ihnen zur Verfügung stellen kann! Hier hilft Ihnen die Funktion colors() weiter. Über die Konsole eingegeben gibt Sie Ihnen zur R-Version 2.10.1 1965 Farben aus.
Möchten Sie Ihre eigene Farbe kreieren, können Sie die über die Funktion rgb() erledigen:
> Farbe <- rgb(43,33,235, alpha = 200, maxColorValue = 255)
Die ersten 3 Werte beschreiben den Farbton, hier ein blau, und der alpha-Wert gibt die Helligkeit wieder. Als Beispiel werden ein paar Punkte grafisch ausgegeben:
> plot(1:6, pch = 20, col = Farbe)
|
|
|
Grafik, “Errorbar”, Abweichungen darstellen
|
Oft besteht der Wunsch, neben der Ausgabe einer z. B. linearen Funktion auch die Residuen grafisch darzustellen. Ohne Aufwand können Sie dies mit der Funktion errbar() aus dem Paket Hmisc erreichen. Ausgehend von folgendem Beispieldatensatz...
... wird Ihnen über den Funktionsaufruf...
> errbar(Beispiel$X, Beispiel$Y, Beispiel$Ymax, Beispiel$Ymin, xlab="X-Daten", ylab="Y-Daten", main="Residuen-Beispiel")
... neben den X-Y-Werten die Abweichungen (Ymin und Ymax) grafisch ausgegeben:
|
|
|
Grafik, Legende (Achsenbeschriftun g)
|
Grafikfunktionen wie plot() nehmen Ihnen in der grafischen Darstellung Ihrer Daten schon viel Arbeit ab, indem Sie sich keine Gedanken über die Achsenformatierung und -beschriftung machen müssen. Möchten Sie irgendwann aber Ihre eigene Achsenbeschriftung vornehmen, ist diese Automatismus störend.
In dem hier beispielhaft verwendeten Datensatz würde in der grafischen Darstellung über plot() der Index als x-Achsenbeschriftung dargestellt. Als Beschriftung soll aber der zeitliche Verlauf der Zeitreihe als x-Achse ausgegeben werden, wie in der Grafik gelb markiert.
Dies kann in zwei Schritten erreicht werden. Im 1. Schritt wird die durch plot vorgegebene x-Achsenbeschriftung über den Parameter xaxt="n" ausgeschaltet:
> plot(Rohoel$Preis, type="o", main="Rohölpreis", ylab="Preisindex", xlab="Zeitraum", xaxt="n")
Das x-Achsenlabel Zeitraum wurde aus Platzgründen in obiger Grafik nicht dargestellt. Im 2. Schritt wird über die Funktion axis() die 98 Labelwerte aus dem Vektor Rohoel$Monat der x-Achse (1) zugeordnet und dargestellt:
> axis(1,at=seq(1:98), labels=Rohoel$Monat)
Die von Ihnen gewünschte Achse wird über den ersten Parameter, hier 1 für die x-Achse, der Funktion axis() angesprochen.
|
|
|
Grafik, Legende (Achsenbeschriftun g, Schriftyp)
|
Möchten Sie einen Teil der Legende besonders hervorheben, können Sie dieses wie im Folgenden Beispiel gezeigt erreichen:
> plot(Daten$Y ~ Daten$X, xlab=(expression(Das ~ sind ~ italic(meine) ~ x-Daten)), ylab=expression(Das ~ sind ~ bold(meine) ~ y-Daten))
(bold = fett, italic = kursiv)
Müssen Sie griechische Buchstaben im Legendentext darstellen, können Sie dieses über die Funktion expression() erreichen:
> Legende <- expression(paste(phi, " /", "cm"))
> plot(Daten, xlab <- Legende)
|
|
|
Grafik, Legende
(Zahlendarstellung)
|
Möchten Sie z. B. die Daten der X-Achse z. B. mit einem Tausender-Trennzeichen versehen, können Sie dieses über die Funktion prettyNum() erreichen. Folgendes Beispiel zeigt die Funktionsweise:
Die x-Daten sollen die zukünftige X-Achse darstellen:
Die x-Daten werden zu Label-Daten über prettyNum() aufgehübscht:
> x_label <- prettyNum(x, big.mark = ".")
> x_label
[1] "10.000" "20.000" "30.000" "40.000"
Die y-Daten werden grafisch ausgegeben und dabei wird wie im obigen Beispiel die X-Achse zuerst unterdrückt...
> plot(y, type="o", main="prettyNum-Beispiel", ylab="Y-Achse", xlab="X-Achse", xaxt="n")
... und nun als X-Achse die Labels ausgegeben:
> axis(1, at=seq(1:4), labels=x_label)
Hier das Resultat:
|
|
|
Hilfe, zusätzliche Unterstützung
NEU!
|
Über das Paket SOS erhalten zusätzliche nützliche Hilfefunktionen. Nach dem Laden des Paketes erhalten Sie über die ???-Funktion Informationen in welchen Paketen (wenn möglich) die gesuchte Funktion enthalten ist. Suchen Sie z. B. die spline-Funktion gehen Sie wie folgt vor:
Das Suchergebnis wird in dem Objekt Ergebnis abgelegt und die Anzahl der Treffer ausgegeben:
Rufen Sie das Ergebnis auf ...
... wird Ihnen das Suchergebnis im Browser angezeigt:
Klicken Sie im linken Bereich Description and Link auf einen entsprechenden Link, wird Ihnen die HTML-Hilfe zum Paket bzw. zur Funktion angezeigt!
|
|
|
if-Variante
|
Im Folgenden wird eine verkürzte if-Abfrage beschrieben. Aber Vorsicht! Denken Sie hier bei der Verwendung an die Lesbarkeit des Codes!
Die Variable Daten beinhaltet z. B.: "a" "b" "b" "b" "c". Daten soll auf b’s geprüft werden und wenn vorhanden, gegen z’s ausgetauscht werden:
|
|
|
Interpolation
|
Eine einfache aber dennoch oft gestellte Frage: Wie werden in R Zwischenwerte interpoliert? Sie erreichen dies über die Funktion approx(). Im Folgenden Beispiel werden die Werte zwischen 1 und 10 linear interpoliert:
> x <- c(0, 10)
> resultat <- approx(x, method="linear")
> resultat$y
[1] 0.0000000 0.2040816 0.4081633 0.6122449 0.8163265 1.0204082
[7] 1.2244898 1.4285714 1.6326531 1.8367347 2.0408163 2.2448980
[13] 2.4489796 2.6530612 2.8571429 3.0612245 3.2653061 3.4693878
[19] 3.6734694 3.8775510 4.0816327 4.2857143 4.4897959 4.6938776
[25] 4.8979592 5.1020408 5.3061224 5.5102041 5.7142857 5.9183673
[31] 6.1224490 6.3265306 6.5306122 6.7346939 6.9387755 7.1428571
[37] 7.3469388 7.5510204 7.7551020 7.9591837 8.1632653 8.3673469
[43] 8.5714286 8.7755102 8.9795918 9.1836735 9.3877551 9.5918367
[49] 9.7959184 10.0000000
Durch den Vorgabewert n = 50 werden 50 Zwischenwerte interpoliert. Die Hilfe zur Funktion approx() zeigt weitere Möglichkeiten.
|
|
|
Menü
(Funktion)
|
Möchten Sie in einer Funktion dem Anwender ein Auswahlmenü anbieten, hilft hier die Funktion menu() weiter:
Auswahl <- c(menue_text_1, menue_text_2)
switch(menu(Auswahl, title = "Menübeispiel"), Auswahl <- 1, Auswahl <- 2)
In einer Funktion eingebunden, könnte die Auswahl wie folgt aussehen:
Obige Beispielfunktion können Sie hier downloaden.
|
|
|
PDF-Datei
|
Möchten Sie eine grafische Ausgabe als PDF-Datei speichern, können Sie die grafische Ausgabe über die pdf()-Funktion als PDF-Datei in das eingestellte Verzeichnis umleiten:
> pdf(file="Test.pdf")
> hist(Daten, main="Beispielhistogramm")
> dev.off()
pdf
3
>
Das Objekt Daten beinhaltet die Beispieldaten und ist nicht weiter spannend. Hier geht es nur darum, die Ausgabe des Histogramms umzuleiten, Die offene PDF-Datei, die hier die Bezeichnung Test.pdf trägt, wird durch die Funktion dev.off() geschlossen. Danach kann die PDF-Datei Acrobat geöffnet werden:
|
|
|
Programmier-Tipp
(Ausnahmen behandeln)
|
Sie entwickeln eine Funktion, die eine vom Nutzer anzugebende Datei öffnen und verarbeiten soll. Dabei kann es passieren, dass der Nutzer sich verschreibt. Der Dateiname oder das Verzeichnis entspricht nicht der Erwartung, somit lässt die Datei sich nicht öffnen und die Ausführung der Funktion wird mit einer entsprechenden Meldung abgebrochen.
Das Abbruchverhalten können Sie über die Behandlung von Ausnahmen steuern! Die folgende kleine Beispielfunktion Test soll eine csv-Datei einlesen und den Dateiinhalt auf der Konsole ausgeben:
> Datei
[1] "C:/Users/Günter/Documents/Statistik/Zwischen/Wirkstoff.csv"
> Test <- function(Datei) {
+ if(file.exists(Datei)) {
+ Daten <- read.csv2(Datei)
+ print(Daten)
+ } else {
+ stop("Datei kann nicht geöffnet werden! Datei: ", Datei)
+ }
+ }
Über die Funktion file.exists() wird auf das Vorhandensein der Datei geprüft. Ist die Datei nicht vorhanden, wird die stop()-Funktion im else-Teil ausgeführt. Die stop()-Funktion bricht die Abarbeitung der Funktion Test ab. Ist dieses Verhalten nicht nötig, kann die stop()-Funktion durch die warning()-Funktion ersetzt werden. In diesem Falle, wird die Funktion durchlaufen und zum Schluss einen Warnmeldung ausgegeben.
Zuerst soll das normale Verhalten - der Nutzer hat alles richtig eingegeben - gezeigt werden:
> Test(Datei)
Wirkstoff.A Wirkstoff.B Wirkstoff.C Pruefer Datum
1 99.1 97.3 95.3 Karl 10.08.10
2 99.3 97.5 95.1 Karl 11.08.10
3 98.8 96.9 95.6 Peter 12.08.10
4 98.9 97.2 95.7 Karl 13.08.10
5 99.3 97.4 95.1 Peter 14.08.10
6 99.2 97.1 95.5 Peter 15.08.10
7 99.5 97.0 95.6 Karl 16.08.10
8 99.4 96.9 95.4 Peter 17.08.10
9 99.0 97.4 95.8 Peter 18.08.10
Und nun das Verhalten, wenn die Datei Wirkstoff.csv nicht in dem angegebenen Verzeichnis vorhanden ist:
> Test(Datei)
Fehler in Test(Datei) :
Datei kann nicht geöffnet werden! Datei: C:/Users/Günter/Documents/Statistik/Zwischen/Wirkstoff.csv
|
|
|
Programmier-Tipp
(Name des übergebenen Datensatzes)
|
Möchten Sie die Bezeichnung des an einer programmierten Funktion übergebenen Datensatzes auslesen und z. B. in der Funktionsausgabe ausgeben, hilft die Funktionkombination deparse(substitute(x)) weiter:
Die Ausgabe kann dann wie folgt aussehen:
Untertitel <- paste(Untertitel, " (Datensatz: ", Fakt.Daten.Namen, ")")
Das Beispiel wurde in der Funktion Faktorenanalyse realisiert. Der übergebene Datensatz trägt die Bezeichnung Fakt.Beispiel:
> faktorenanalyse(Fakt.Beispiel,labelsp=T,info=T,grafik=T)
Die grafische Ausgabe zeigt dann die Bezeichnung des Datensatzes im Untertitel:
|
|
|
Programmier-Tipp (Nutzer-Eingabe abfragen)
|
Möchten Sie dem Nutzer während der Funktionsausführung Gelegenheit geben, den Funktionsablauf zu beeinflussen oder Eingaben durchzuführen, bietet R Ihnen die Funktion winDialog() an.
Möchten Sie dem Anwender Möglichkeiten zur Beeinflussung des Programmablaufes geben, können Sie die Funktion winDialog() wie folgt nutzen:
> Nachricht <- "Meine Nachricht!" #Nachricht für den Nutzer
> # In dem Objekt Eingabe wird die Eingabe abgelegt:
> Eingabe <- winDialog(type = c("yesnocancel"),Nachricht)
Durch obige Funktion wird dem Nutzer folgendes Dialog-Fenster dargestellt:
Wie Sie erkennen können, bestimmt das Argument type die angebotenen Schaltflächen. Es stehen Ihnen die Möglichkeiten “ok”, “okcancel”, “yesno” und “yesnocancel” zur Verfügung. Die durch den Nutzer gedrückte Schaltfläche - das Ereignis - wird in der Variablen Eingabe abgelegt:
Im hier dargestellten Beispiel wurde die Schaltfläche Ja gedrückt und damit “YES” als Zeichenkette in der Variable Eingabe abgelegt. Die Variable lässt sich nun prüfen und z. B. dementsprechend eine Programmverzweigung durchführen.
Es können vom Nutzer auch konkrete Eingaben über die Funktion winDialogString() abgefragt werden. Im Folgenden soll der Nutzer eine Eingabe in dem Wertebereich von 0 bis 10 durchführen, wobei 1,5 als Vorgabewert festgelegt wird:
> Nachricht <- "Bitte geben Sie den Wertebereich von 0 bis 10 ein:"
> Vorgabe <- "1.5"
> Eingabe <- winDialogString(Nachricht, Vorgabe)
Der Funktionsaufruf zeigt dann folgendes Dialog-Fenster:
Geben Sie z. B. 2,3 ein, ist der Inhalt der Variablen Eingabe gleich “2.3”. Möchten Sie die Eingabe tatsächlich in einer weiteren Berechnung verwenden, denken Sie an die Typwandlung:
|
|
|
Programmier-Tipp
(Fortschrittsbalken)
NEU!
|
Umfangreichere Berechnungen (Schätzungen) benötigen entsprechende Systemkapazitäten Ihres Computers. Möchten Sie nicht im Unklaren über den Status sein, können Sie sich über einen Fortschrittsbalken über den Berechnungs-Fortschritt machen:
Sie kennen derartige Funktion aus diversen Programmen und möchten Sie diese Funktionalität in Ihren R-Funktionen nutzen, laden Sie hier die Beispielfunktion auf Ihren Computer runter!
|
|
|
Programmier-Tipp
(beliebiger Programmaufruf / URL Aufruf)
NEU!
|
Besteht die Notwendigkeit aus einer Funktion z. B. ein Windows-Programm aufzurufen, können Sie dies über die shell.exec()-Funktion erreichen. Im Folgendem Beispiel wird der Eitor Ultraedit aufgerufen:
> shell.exec("C:/Program Files/IDM Computer Solutions/UltraEdit-32/uedit32.exe")
Über diese Funktion lassen sich auch URL’s aufrufen:
> shell.exec("http://www.faes.de")
Das URL-Beispiel können Sie direkt ohne Anpassungen ausführen!
|
|
|
OpenOffice
|
Mit dem Paket odfWeave können Sie Ihre Daten oder Grafiken immer aktuell in einem OpenOffice-Dokument einbinden. D. h., Sie können aus der R-Umgebung Informationen an ein OpenOffice-Textdokument schicken und verfügen dadurch immer über einen aktuellen Bericht. Dazu sind einige wenige Schritte erforderlich.
Im 1. Schritt muss das Paket odfWeave installiert werden. Nutzen Sie die R-Version 2.5.1 sollten folgende Pakete geladen sein:
Im obigen Beispiel wurden die Pakete XML und lattice vom Paket odfWeave nachgeladen. Um nun im 2. Schritt z. B. den Datensatz Daten in einem OpenOffice-Textdokument auszugeben, sind folgende Anweisungen zwischen << und dem @ im Textdokument nötig:
Dieses OpenOffice-Textdokument speichern Sie z. B. unter den Namen Test.odt und als 3. Schritt geben Sie auf der R-Konsole folgende Anweisung ein:
odfWeave("C:/Programme/Statistik/R-2.5.1/Eigene_Projekte/Test.odt",
"C:/Programme/Statistik/R-2.5.1/Eigene_Projekte/Test2.odt")
Mit dieser Anweisung müssen Sie auch die Zieldatei Test2.odt angeben! Die odfWeave-Funktionalität erstellt eine neue Datei, die Zieldatei, um dort den Inhalt von Test.odt und die R-Informationen abzuspeichern. So könnte die Zieldatei Test2.odt aussehen:
Auch Grafiken lassen sich einbinden. Das nächste Bild zeigt das Einbinden der plot()-Funktion ...
... und nach dem Aufruf der obigen R-Anweisung wird Test2.odt erneut erzeugt und zeigt nun zusätzlichen Inhalt:
Hier können Sie die Datei Test.odt zur Ansicht laden. Das Paket odfWeave bietet noch weiter Möglichkeiten, schauen Sie einfach mal...!
|
|
|
Rückgabe, (Funktion)
|
Gewöhnlich wird das Funktionsresultat über return(x) an die Konsole zurückgegeben. Diese Rückgabe ist natürlich keine Verpflichtung, wie schon in einigen Funktionen gezeigt. Als Zwischenlösung kann die Funktionsrückgabe über invisible(x) betrachtet werden.
D. h., dass komplette Funktionsergebnis kann an ein Objekt (z. B. a) übergeben werden:
a <- funktion(x)
Das Objekt a beinhaltet, wie gewöhnlich, das Funktionsresultat. Wenn Sie nur funktion(x) aufrufen, erhalten Sie keine Ausgabe! Sie wird durch invisible(x) unterdrückt.
|
|
|
Syntaxhervorhebung
|
Schreiben Sie eigene Funktionen, sind Editoren mit Syntaxhervorhebung sehr hilfreich. Syntaxhervorhebung bedeutet, dass der Editor Ihren eingegeben Code auf R-Funktionen und Schlüsselwörter/Zeichen überprüft und diese farblich besonders darstellt (siehe ...-Argument):
Nun kommt ein bisschen Werbung: Ich nutze den Editor UltraEdit-32 und dieser bietet eine Wortlistendatei (rechte Maustaste -> Ziel speichern unter...) für R zur Syntaxhervorhebung an. Diese Datei wird unter Extras -> Optionen wie gezeigt in den Editor eingebunden:
|
|
|
Verzeichnis anzeigen
|
R bietet Ihnen Funktion zum Einlesen eines Verzeichnisses z. B. über die Funktionen dir() oder list.files(). Über das Attribut pattern kann der auszulesende Dateityp festgelegt werden. Möchten Sie nun Dateien vom Typ “csv” auslesen, gehen Sie sicher wie folgt vor:
Die Datei 7 (gelbe Markierung) ist allerdings nicht vom Typ “csv” sondern trägt csv in der Dateibezeichung. Um auch diese Dateien auszuschließen, müssen das Argument pattern um “\\” ergänzen:
Die Datei “lindacsv.lda.R” wird ausgeschlossen.
|
|
|
Zeit
|
Berechnungen mit der Zeit
Die Systemzeit, einschließlich Ihrer Zeitzone, wird über die Funktion
ausgegeben (CET = Central European Time). Über die Funktion ISOdate() und dem Parameter tz zur Einstellung der Zeitzone (tz=”” -> Zeitzone Ihres Computers), belegen Sie Variablen mit den von Ihnen gewünschten Zeiten:
> Zeit_1 <- ISOdate(2005,1,1, tz="")
> Zeit_1
[1] "2005-01-01 12:00:00 CET"
> Zeit_2 <- ISOdate(2008,11,8, 18,10,05, tz="")
> Zeit_2
[1] "2008-11-08 18:10:05 CET"
Möchten Sie Zeitdifferenzen berechnen, bietet R Ihnen die Funktion difftime() an:
> difftime(Zeit_2, Zeit_1)
Time difference of 1407.257 days
> difftime(Zeit_2, Zeit_1, units="weeks")
Time difference of 201.0367 weeks
Möchten Sie eine Datenobjekt mit einer Sequenz von beispielsweise 10 Tage erzeugen, können Sie dies mit der Funktion seq(as.Date()) erreichen:
> Tage <- seq(as.Date("2008-11-1"), by = "days", length = 10)
> Tage
[1] "2008-11-01" "2008-11-02" "2008-11-03" "2008-11-04" "2008-11-05"
[6] "2008-11-06" "2008-11-07" "2008-11-08" "2008-11-09" "2008-11-10"
Angeboten werden Ihnen folgende Varianten:
# Variante 1:
> Tage <- seq(as.Date("2008-11-1"), to = as.Date("2008-11-8"), by = "days")
> Tage
[1] "2008-11-01" "2008-11-02" "2008-11-03" "2008-11-04" "2008-11-05"
[6] "2008-11-06" "2008-11-07" "2008-11-08"
# Variante 2, vom Starttag um jeweils eine Woche weitergezählt:
> WochenTage <- seq(as.Date("2008-11-2"), to = as.Date("2008-11-30"), by = "weeks")
> WochenTage
[1] "2008-11-02" "2008-11-09" "2008-11-16" "2008-11-23" "2008-11-30"
Als Parameter für den by-Parameter sind neben den bereits gezeigten Argumente days und weeks auch die Argumente months und years zulässig.
|
|
|
