close

Anmelden

Neues Passwort anfordern?

Anmeldung mit OpenID

C–R–ash-Kurs Grundlagen Was ist S? Was ist R? - Institut für Statistik

EinbettenHerunterladen
Grundlagen
C–R–ash-Kurs
Torsten Hothorn
Institut f¨
ur Statistik
Was ist S?
Was ist R?
S ist eine Sprache f¨
ur Datenanalyse und Graphik, entwickelt von
John Chambers und Kollegen in den Bell Laboratories um
• interaktives Rechnen mit Daten in einer
R ist eine Implementation der Sprache S, anf¨
anglich von Ross
Ihaka und Robert Gentleman (Univ. Auckland) entwickelt und
seit Mitte der 90iger Jahre von einem Entwickler-Kollektiv (RCore) betreut.
• vollwertigen interpretierten Programmiersprache, die
Informationen zu R unter
• den Benutzern Zugang zu allen Strukturen und
• Graphik f¨
ur explorative Datenanalyse und Publikationszwecke
bietet, zu erm¨
oglichen.
http://www.R-project.org
Wo bekomme ich R?
Fertige R Distributionen sind f¨
ur Windows 95, 98, ME, NT4,
2000 und XP f¨
ur Intel-Prozessoren, f¨
ur MacOS X und viele LinuxVersionen auf CRAN – dem Comprehensive R Archive Network
– erh¨
altlich:
http://CRAN.R-project.org.
Wie installiere ich R?
Windows: F¨
uhre die Datei ‘R-2.5.0-win32.exe’ von http://CRAN.
R-project.org/bin/windows/base aus und klicke ”Next” bis zum
gl¨
ucklichen Ende (”Finish”).
Unix:
Nat¨
urlich ist dort auch der vollst¨
andige Quellcode erh¨
altlich,
jeweils in der aktuellen Version (zur Zeit: 2.5.0).
$
$
$
$
$
wget -c http://CRAN.R-project.org/src/base/R-2.5.0.tgz
tar -xzvf R-2.5.0.tgz
./configure
make && make check
make install
Wie starte ich R?
R als Tischrechner
Windows: Auf das R-Symbol klicken.
Ok. Aller Anfang ist schwer, also zun¨
achst mal was Bekanntes...
Unix:
> 1 + 1
[1] 2
$ R
Es wird eine Kommando-Zeilen-Schnittstelle gestartet. Unter
Windows ist diese in das ¨
ublichen Fenster-Schema eingepaßt und
einige wichtige Aktionen sind per Men¨
u ausf¨
uhrbar.
> a <- 0.5
> b <- a * 2
> exp(b)
[1] 2.718282
R Grundlagen
Hilfe:
Operatoren:
Schleifen:
help(topic)
?topic
help.start()
+, -, *, /, ^
&, &&, |, ||
siehe help("+")
for, while, if
R Grundlagen
Zuweisungen:
Vergleiche:
Kommentare:
Elementare Datentypen
logical:
TRUE, FALSE, T, F
integer:
1, 100, 326, ...
double:
1.0, 3.1415297, 2.718282,
NaN, Inf, -Inf
complex:
1+0i, 1i, 3+5i
character:
"Hallo", "Wie geht’s?"
fehlende Werte: NA
x <- 5
x <- 5
5 -> x
==, !=, >, >=, <,
<=
siehe help("==")
alles nach #
Namen: Groß/Kleinschreibung wichtig, beginnen mit Buchstaben, Achtung bei “Underscore”
Alle elementaren Datentypen sind ausschließlich als Vektoren
verf¨
ugbar (es gibt keine Skalare), jeder Vektor enth¨
alt 0 oder
mehr Elemente desselben Typs, eventuell gemischt mit NA.
R Grundlagen
R Grundlagen
Wir unterscheiden zwischen Modus und Speichermodus eines
Vektors:
> mode(1:10)
array:
[1] "numeric"
> storage.mode(1:10)
[1] "integer"
matrix:
> mode(pi)
[1] "numeric"
> storage.mode(pi)
[1] "double"
factor:
list:
> mode(TRUE)
[1] "logical"
> mode("Hello")
[1] "character"
data frame:
Komplexere Datentypen
Vektor mit Dimensionsattribut, Anzahl der Dimensionen ist de facto nur durch den verf¨
ugbaren
Hauptspeicher beschr¨
ankt.
2-dimensionaler Array, Spezialfall um ¨
ubliche
Matrixoperationen
(Multiplikation,
...)
zu
erm¨
oglichen.
spezieller Vektor f¨
ur kategorielle Merkmale.
kombiniert Elemente verschiedener Typen (inkl.
Listen → rekursive Strukturen).
“Mischung” aus Matrix und Liste.
Konstruktion & Umwandlung
Konstruktion & Umwandlung
• Funktionen zum Erzeugen von Datentypen haben ¨
ublicherweise
denselben Namen wie der betreffende Datentyp (ein generelles Prinzip in S), Methoden zur Konversion zwischen ver¨ berpr¨
schiedenen Typen haben Namen wie as.xxx(), U
ufung
des Typs erfolgt mit is.xxx().
R>
R>
R>
R>
R>
R>
R> c(1,2,7)
R> c("Hallo", "Welt")
integer(5)
double(0)
x <- matrix(1, nrow=5, ncol=2)
is.matrix(x)
as.vector(x)
x <- list(a="Hallo", b=1:10, pi=3.1415927)
• Konstruktion einfacher Vektoren
Konstruktion & Umwandlung
• S wandelt den Typ eines Objektes automatisch um, wenn
dies notwendig und m¨
oglich ist:
> TRUE + 2
[1] 3
> c("Hello", 100)
[1] "Hello" "100"
• Beispiele f¨
ur h¨
aufige Konversionen sind
logisch
→numerisch
logisch, numerisch
→komplex
logisch, numerisch, komplex→Text
numerisch, komplex
→logisch
NA, NaN und NULL
Alle drei k¨
onnen als Darstellung von “Nichts” angesehen werden, allerdings ist die Ursache f¨
ur das Fehlen der Information
verschieden:
NA: fehlende Werte in der Stichprobe, unzul¨
assige Konversionen, . . .
NaN: ¨
ahnlich zu NA, aber die Ursache des Fehlens ist bekannt:
eine mathematische Operation liefert kein Ergebnis, z.B. weil
eine Funktion außerhalb ihres Definitionsbereiches verwendet
¨ blicherweise begleitet von Warnung.
wurde (log(−1), . . . ). U
NULL: Zeiger auf Nichts im informatischen Sinn
> c(3, NA)
[1]
3 NA
> c(3, NaN)
[1]
3 NaN
> c(3, NULL)
[1] 3
Unendlich
Zugriff auf einzelne Elemente
Vektoren: durch Nummer, Name oder logischen Vektor
Die beiden speziellen Symbole Inf und -Inf k¨
onnen wie Zahlen
in vielen mathematischen Rechenoperationen verwendet werden:
> max(3, NA)
[1] NA
> min(3, NA)
R>
R>
R>
R>
R>
x <- c(5,3,7)
names(x) <- c("apple","banana","orange")
x["apple"]
x[1:2]
x[c(T,T,F)]
[1] NA
> max(3, Inf)
[1] Inf
Arrays: wie Vektoren, Dimensionen durch Komma getrennt
> min(3, Inf)
[1] 3
Achtung: manche numerische Verfahren k¨
onnen nicht mit Unendlich rechnen und liefern Fehlermeldungen.
Zugriff auf einzelne Elemente
R>
R>
R>
R>
R>
x <- matrix(1:10, ncol=2); colnames(x) <- c("Eins", "Zwei")
x[1:2,]
# liefert eine Matrix
x[,"Zwei"]
# liefert einen Vektor
x[,"Zwei",drop=F]
# liefert eine Matrix
x[-3,]
# alles außer Zeile 3
Data frames
• Duale Sichtweise:
Listen: Dollarzeichen oder Nummer/Name
R> x <- list(a="Hallo", b=1:10, pi=3.1415927)
R> x$a
R> x[["a"]]
R> x[[1]]
R> x[1]
## erstes Element der Liste
## Liste mit einem Element
R> x[2:3]
## Liste mit zwei Elementen
R> x[[2:3]] ## FEHLER!
– Matrix in der jede Spalte einen anderen Datentyp haben
kann
– Liste in der jedes Element dieselbe L¨
ange haben muß
• Zugriff auf Elemente wie bei Matrizen oder Listen:
R>
R>
R>
R>
R>
data(iris)
iris[1:10,]
iris[,1]
iris$Sepal.Length
iris[,1,drop=FALSE]
##
##
##
##
data frame mit 10 Zeilen
numerischer Vektor
dasselbe
data frame mit einer Spalte
Attribute
Attribute
Sind wie Pickerl auf einem Marmeladeglas“ und erm¨
oglichen
”
die detailliertere Beschreibung des Inhaltes. So ist z.B. ein Array
nur ein Vektor mit einem Dimensionsattribut. Weitere h¨
aufige
Attribute beinhalten Namen f¨
ur die Zeilen oder Spalten einer
Matrix, Elemente einer Liste, . . .
> rownames(x) <- c("Eins", "Zwei")
> x
$dimnames[[2]]
NULL
> attributes(x)
$dim
[1] 2 5
Attribute
Klassen
Die as.xxx() Funktionen l¨
oschen alle Attribute, inklusive der
Dimensionalit¨
at:
> x <- matrix(1:10, nrow = 2)
> x
[,1] [,2] [,3] [,4] [,5]
1
3
5
7
9
2
4
6
8
10
> as.character(x)
"2"
"3"
> attributes(x)
$dimnames
$dimnames[[1]]
[1] "Eins" "Zwei"
[,1] [,2] [,3] [,4] [,5]
[1,]
1
3
5
7
9
[2,]
2
4
6
8
10
[1] "1"
[,1] [,2] [,3] [,4] [,5]
1
3
5
7
9
2
4
6
8
10
$dim
[1] 2 5
> x <- matrix(1:10, ncol = 5)
> x
[1,]
[2,]
Eins
Zwei
"4"
"5"
"6"
"7"
> storage.mode(x) <- "character"
> x
[,1] [,2] [,3] [,4] [,5]
[1,] "1" "3" "5" "7" "9"
[2,] "2" "4" "6" "8" "10"
"8"
"9"
"10"
• Ungl¨
ucklicherweise hat S gleich zwei Klassensysteme: S3 und
S4. Wir werden uns nur mit dem viel einfacheren S3 System
besch¨
aftigen.
• Ein spezielles Attribut jedes Objektes beschreibt seine Klas”
se“, dies erm¨
oglicht einfaches objekt-orientiertes Program¨ berladen von Funktionen.
mieren und das U
¨ berpr¨
• Setzen und U
ufen der Klasse eines Objektes:
R> class(y)
R> class(y) <- "newclass"
• Generische Funktionen verhalten sich unterschiedlich f¨
ur
Objekte verschiedener Klassen.
Klassen
> x <- rep(0:1, c(10, 20))
> x
[1] 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
> class(x)
[1] "integer"
Funktionen
> summary(x)
Min. 1st Qu.
0.0000 0.0000
Median
1.0000
Mean 3rd Qu.
0.6667 1.0000
Max.
1.0000
> y <- as.factor(x)
> class(y)
[1] "factor"
> summary(y)
0 1
10 20
Funktionen
• Obwohl S-Plus und R bereits in der Standardinstallation
extrem m¨
achtige Werkzeuge zur Datenanalyse darstellen,
wollen die meisten Benutzer nach einiger Zeit dieses Werkzeug ihren eigenen Bed¨
urfnissen anpassen.
• Einer der gr¨
oßten Vorteile von S ist, daß jeder Benutzer
das System leicht um eigene Funktionen erweitern oder
bestehende Funktionen modifizieren kann.
• Der gr¨
oßte Teil von R selber ist in der Sprache S geschrieben.
• S ist eine vollwertige Programmiersprache in deren Design die
Notwendigkeiten der statistischen Datenanalyse mit einbezogen wurden, es ist nicht nur eine Sprache zur Datenanalyse.
Formale Definition
function ( ARGLIST ) K¨
ORPER
• Das Schl¨
usselwort function markiert den Beginn einer Funktionsdefinition.
• Die Argumente der Funktion werden durch eine mit Kommas
getrennte Liste von Ausdr¨
ucken der Form SYMBOL = AUSDRUCK
oder durch das spezielle formale Argument ... angegeben.
• Jeder g¨
ultige R Ausdruck kann als K¨
ORPER der Funktion
verwendet werden, zumeist ist es ein durch geschwungene
Klammern gruppierter Block von Anweisungen.
• In den meisten F¨
allen werden Funktionen Symbolen zugewiesen ( bekommen einen Namen“), aber auch anonyme
”
Funktionen sind an gewissen Stellen sehr praktisch (apply(),
. . . ).
Funktionen aufrufen
Funktionen aufrufen
Beispiel:
moment <- function(x, n=2) {
sum(x^n)/length(x)
}
• Funktionen retournieren nur eine einziges Objekt: den Wert
des letzten Ausdruckes oder das Argument von return(). In
der Praxis ist dies nicht allzu restriktiv, da das zur¨
uckgelieferte
Objekt eine beliebig komplexe Liste sein kann.
• Benannte Argumente: Wenn eine Funktion aufgerufen wird,
m¨
ussen die Argumente nicht in derselben Reihenfolge wie in
der Funktionsdefinition angegeben werden, sondern k¨
onnen
auch direkt mit Namen angesprochen werden, z.B. moment(n=3,
x=myx).
Das ... Argument
• Funktionen k¨
onnen beliebig viele unspezifizierte Argumente
besitzen, falls die Argumentliste das spezielle Argument ...
enth¨
alt, z.B. max(..., na.rm = FALSE).
• Eine zweite Verwendungsm¨
oglichkeit ist das Weiterleiten von
Argumenten an eine andere Funktion:
myplotfun <- function(x, y, myarg, ...)
{
## do some computations using x, y and myarg
## then call the standard plot function
plot(x, y, ...)
}
Damit versteht“ myplot() zus¨
atzlich zu seinen eigenen
”
Argumenten implizit auch alle Argumente von plot() ohne
weiteren Programmieraufwand.
• x <- list(...) im K¨
orper einer Funktion konvertiert alle
unspezifizierten Argumente in eine benannte Liste.
• Argumente mit Defaultwerten m¨
ussen beim Aufruf nicht
spezifiziert werden, z.B. moment(myx).
• Defaultwerte k¨
onnen Funktionen anderer Argumente sein.
Argumente zusammenf¨
ugen
Wenn eine Funktion aufgerufen wird, werden die tats¨
achlichen
Argumente des Funktionsaufrufen mit den formalen Argumenten
der Funktionsdefinition in der folgenden Reihenfolge zusammengef¨
ugt:
1. alle benannten Argumente deren Namen dem eines formalen
Argumentes exakt entspricht
2. wenn kein ... Argument definiert wurde gen¨
ugt eine eindeu¨ bereinstimmung am Beginn des Namens
tige U
3. Position in der Argumentliste
4. Verbleibende tats¨
achliche Argumente werden Teil von ...
(falls definiert).
Anmerkung: Nicht alle formalen Argumente m¨
ussen auch durch
tats¨
achliche Argumente abgedeckt werden.
Lazy Evaluation
Beim Aufruf einer Funktion werden die Argumente nur geparsed,
aber nicht evaluiert. Die Auswertung des Argumentes erfolgt
erst, wenn das Argument zum ersten Mal verwendet wird:
> myfun <- function(x, y) {
+
if (x < 0)
+
return(NaN)
+
else return(y * log(x))
+ }
> myfun(-1)
Flußkontrolle
• Als vollwertige Programmiersprache besitzt S eine Reihe von
Strukturen zur Kontrolle des Programmflusses.
• Iterationen werden durch die Befehle for, while und repeat
zur Verf¨
ugung gestellt.
• F¨
ur bedingte Auswertungen k¨
onnen if, else und switch()
verwendet werden.
[1] NaN
> myfun(2, 3)
[1] 2.079442
• for und if sind von diesem die bei weitem am h¨
aufigsten
verwendeten.
> myfun(2)
Error in myfun(2) : Argument "y" is missing, with no default
Der if Befehl
if else Konstrukte haben die Form
if( Test ) {
Anweisungsblock 1
} else {
Anweisungsblock 2
}
if: Beispiele
• Ein typisches Beispiel f¨
ur die Verwendung von if:
if (any(x < 0)){
stop("negative Werte in x")
}
• Auswahl zwischen mehreren M¨
oglichkeiten::
Wenn der Test den Wert TRUE liefert, wird Anweisungsblock 1
ausgef¨
uhrt, sonst Anweisungsblock 2.
Der else-Teil ist optional.
if (all(x >= 0))
sqrt(x)
else
sqrt(x + 0i)
if: Beispiele
Der for Befehl
for Konstrukte haben die Form
• Verschachtelte if Befehle:
if (x <= 0){
return(0)
}
else if( x>0 && x<=1){
return(x)
}
else {
return(1)
}
for(var in vector) {
Schleife
}
In jedem Iterationsschritt wird die Variable var der Reihe nach
auf jeweils das n¨
achste Element des Vektors vector gesetzt und
dann die Schleife durchlaufen.
(eher sinnloses Beispiel da nicht vektorisiert)
Dies sieht ¨
ahnlich wie die entsprechenden Konstrukte von
Sprachen wie C oder C++ aus, ist aber syntaktisch n¨
aher am
foreach Befehl der Sprache Perl.
for: Beispiele
Der while Befehl
while Konstrukte haben die Form
• Summation der Elemente eines Vektors im Stil von C:
summe <- 0
for(i in 1:length(x)) {
summe <- summe + x[i]
}
• Summation der Elemente eines Vektors im Stil von Perl:
summe <- 0
for(elt in x) {
summe <- summe + elt
}
while( Test ) {
Schleife
}
Die Schleife wird immer wieder durchlaufen, bis der Test zum
ersten Mal FALSE liefert.
Beispiel: Summation bis zum ersten fehlenden Wert
• Die zweite Variante ist effizienter.
summe <- 0
i <- 1
while((i <= length(x)) && !is.na(x[i])){
summe <- summe + x[i]
i <- i+1
}
next und break
next Springt zum Beginn der n¨
achsten Iteration einer for oder
while Schleife.
break Beendet eine for oder while Iteration vorzeitig.
Methoden
Beispiel: Summation bis zum ersten fehlenden Wert
summe <- 0
i <- 1
while(i <= length(x)){
if(is.na(x[i])) break
summe <- summe + x[i]
i <- i+1
}
Objekt-orientierte Programmierung
Gr¨
unde f¨
ur OOP:
Objekt-orientierte Programmierung
Beispiel: mit
• Erh¨
ohung der Produktivit¨
at
R> lm1 <- lm(y~x)
• leichtere Wartung des eigenen Codes
• Wiederverwendung von Code-Bausteinen
wurde ein lineares Modell angepaßt. Welches der beiden Kommandos
• das Design spiegelt das modellierte Objekt (meistens) n¨
aher
wider
R> lm1$coef
R> coef(lm1)
• Abstraktion zwischen Implementierung und Verwendung von
Funktionalit¨
at
ist besser geeignet, um die Koeffizienten zu extrahieren?
Klassen & Instanzen
• eine Klasse ist die abstrakte Definition eines Objektes
Klassen & Instanzen
Die Grundbausteine jedes Klassensystems sind:
• eine Instanz ist eine Realisierung einer Klasse
• Definition von Klassen, Erzeugung von Instanzen der Klasse
• Beispiel:
Klasse ganzzahliger Vektor“, Instanz (1,2,3)“
”
”
• Spezifikation des Vererbungsbaumes
• Feststellung der Klasse und aller Elternklassen eines Objektes
• normalerweise k¨
onne Klassen von Elternklassen erben, d.h.,
sie erweitern diese: Pudel erbt von Hund, Hund erbt von
S¨
augetier, S¨
augetier erbt von Wirbeltier, . . .
Methoden
• Generische Methoden sind Funktionen, die in Abh¨
angigkeit
von der Klasse ihrer Argumente unterschiedliche Berechnungen durchf¨
uhren und eventuell unterschiedliche Ausgaben
zur¨
uckliefern (Polymorphismus).
• Zugriff auf und Modifikationen von Slots der Klasse
S3 Klassen & Methoden
S3 stellt einen einfachen (aber popul¨
aren und m¨
achtigen)
¨
Mechanismus zum Uberladen von Funktionen zur Verf¨
ugung:
• Definition einer generischen Funktion
foo <- function(x, ...) UseMethod("foo")
• In den meisten klassischen“ OO-Programmiersprachen sind
”
Methoden Teile von Instanzen.
• S ist als interaktive Sprache designed, Methoden k¨
onnen zur
Laufzeit vom Benutzer ver¨
andert und an seine Bed¨
urfnisse
angepaßt werden.
• Wenn myx ein Objekt der Klasse "bar" ist, dann sucht S beim
Aufruf von foo(myx) nach Funktionen mit Namen
– foo.bar()
– foo.default()
in der dieser Reihenfolge und ¨
ubergibt alle Argumente an sie.
Dies nennt sich auch Method Dispatch nach dem ersten Argument.
S3 Klassen & Methoden
S3 Klassen & Methoden
> print
function (x, ...)
UseMethod("print")
<environment: namespace:base>
> x <- 1:5
> print(x)
[1] 1 2 3 4 5
> class(x) <- "foo"
> print(x)
[1] 1 2 3 4 5
attr(,"class")
[1] "foo"
> print.foo <- function(x, ...) {
+
cat("foo Objekt der L¨
ange", length(x), ":\n")
+
print(unclass(x))
+ }
> print(x)
foo Objekt der L¨
ange 5 :
[1] 1 2 3 4 5
Um das Benutzen von Methoden so einfach wie m¨
oglich zu
machen (und aus einer Reihe von anderen Gr¨
unden) sollte man
sich an folgende Regeln halten:
• Jede Methode sollte alle Argumente der zugeh¨
origen generischen Funktion haben (inklusive ... falls vorhanden).
• Jede Methode sollte alle Argumente in exakt derselben
Reihenfolge wie die generische Funktion haben und dieselben
Defaultwerte benutzen.
• Dar¨
uber hinaus kann jede Methode eine beliebige Anzahl an
zus¨
atzlichen Argumenten akzeptieren.
Diese Regeln sind nicht Teil der Sprache S, werden von den
Qualit¨
atssicherungsmechanismen von R aber ¨
uberpr¨
uft.
S3: Die Klassen-Bausteine
Definition: nicht notwendig oder m¨
oglich
Erzeugen von Instanzen: einfach Klassenattribut auf beliebiges Objekt setzen
Vererbung: Vektor von Klassennamen (Kinder vor Eltern)
Klasse testen: inherits(object, ’klassenname’)
Zugriff auf Slots: Je nach Basistyp, f¨
ur Listen ¨
uber $ oder [[]].
Graphik
Grafik – Devices
F¨
ur die Grafikausgabe stehen eine Reihe von Ger¨
aten (Devices)
zur Verf¨
ugung, die die folgenden Eigenschaften besitzen:
• Man stelle sich ein Device zun¨
achst vor als ein St¨
uck Papier,
auf das man mit vielen Stiften und Farben malen kann, von
dem aber nicht gel¨
oscht werden kann.
• Mehrere Devices k¨
onnen gleichzeitig ge¨
offnet sein, man kann
aber nur genau in das aktive hineinmalen.
• Man bemerkt keinen Unterschied beim Malen, egal welches
Device man benutzt.
Grafik – Devices
?Devices zeigt Details an und gibt Hinweise auf weitere Hilfeseiten.
postscript(): PostScript Grafiken, z.B. zum Einbinden in LATEX
Dokumente.
pdf(): Portable Document Format. Z.B. zur direkten Pr¨
asentation,
A
Verteilen an andere, oder Einbinden in PDFL TEX Dokumente. Kann gut f¨
ur die Durchsicht sehr vieler Grafiken verwendet
werden.
pictex(): LATEX/PicTEX Ausgabe.
bitmap(): Eine Reihe verschiedener Grafikformate, die ¨
uber GhostScript generiert werden.
Grafik – Devices
Grafik – Devices
Außerdem:
Die ¨
ubliche Reihenfolge zum Produzieren einer Grafik ist:
X11(): Bildschirm–Ausgabe.
png(): PNG Grafiken, ein Format ¨
ahnlich GIF.
jpeg(): JPEG kennt jeder: bei variabler Qualitativ enorm kleine
Dateigr¨
oße m¨
oglich – gut f¨
ur das Internet.
• Device starten, z.B. pdf(’testgrafik.pdf’)
• Grafik erzeugen, z.B. plot(1:10)
und unter Windows
• Device schließen: dev.off()
windows(): Bildschirm–Ausgabe.
win.metafile(): Windows Meta File, damit es auch in MS Word
& Co. klappt.
bmp(): Bitmap – kann jeder lesen, aber enorm groß und nicht
skalierbar.
Wenn man beim interaktiven Arbeiten und gleichzeitig verf¨
ugbarer
GUI den ersten Schritt ausl¨
asst, wird als Device automatisch die
Bildschirmausgabe gestartet, sonst das postscript() Device.
Grafik – High-level Funktionen
Grafik – High-level Funktionen
Zun¨
achst also zu den von base gelieferten Standard-Grafiken.
High-level Funktionen erzeugen bzw. initialisieren eine Grafik.
Einige wichtige und n¨
utzliche High-level Grafikfunktionen sind:
Sehr viele Funktionen k¨
onnen auf verschiedene Objekte angewendet werden und reagieren intelligent“, so dass f¨
ur jedes Objekt
”
meist eine sinnvolle Grafik erzeugt wird.
kontextabh¨
angig
Stabdiagramm
Boxplot
Conditioning Plots
H¨
ohenlinienplot
Funktionen plotten
Dot Plots (Cleveland)
Histogramm
Bilder (3. Dim. als Farbe)
Mosaikplots (kateg. Daten)
Streudiagramm–Matrix
perspektivische Fl¨
achen
QQ–Plot
Grafik – Scatterplotmatrix
Z.B. erzeugt plot() einen Scatterplot bei Eingabe von zwei
Vektoren, Residualplots bei Eingabe eines lm-Objektes (lineares
Modell / Regression), eine per Linie verbundene Zeitreihe bei
Zeitreihenobjekten, usw.
Hier wird die Objektorientiertheit der S Sprache ausgenutzt.
Es ist also schnell ein Streudiagramm, Histogramm, Boxplot
etc. erstellt, so dass man Daten sehr schnell f¨
ur Analysen
anschauen kann.
Grafik – Scatterplotmatrix
65
70
75
80
85
●
●
●
●
●
●
●
85
●
80
●
●
●
●
●● ●
75
●
●
●
●
Height
●
●
●
●
●
●
●
> plot(trees)
●
●
●
●
●
●
●
●
●
●
●
●
70
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●●
●●
●●
●●
●●
● ●
●
●
●
●
●
●
●●
● ●●
●
●●
●
●
●
●
●
●
●
●●
●
●●●●●●
●
●●
●●●
8
●
●
●
●
●
50
Volume
●
●
●
●
●
●
● ●
10 12 14 16 18 20
●●
●
●
30
●
●
●
●
● ●
●
●
●
●●
● ●
10
31 obs. of 3 variables:
8.3 8.6 8.8 10.5 10.7 10.8 11 11 11.1 11.2 ...
70 65 63 72 81 83 66 75 80 75 ...
10.3 10.3 10.2 16.4 18.8 19.7 15.6 18.2 22.6 19.9 ...
● ●
70
’data.frame’:
$ Girth : num
$ Height: num
$ Volume: num
●
●
●
●
●
●
●
●
65
> data("trees")
> str(trees)
●
●
●
●
●
●
●
●
● ●
● ●
●
●
●
8
Girth
●
●
●
●●
10 12 14 16 18 20
plot()
barplot()
boxplot()
coplot ()
contour()
curve()
dotchart()
hist()
image()
mosaicplot()
pairs()
persp()
qqplot()
●
10
30
50
70
Document
Kategorie
Technik
Seitenansichten
9
Dateigröße
166 KB
Tags
1/--Seiten
melden