Ein Beispiel

Nehmen wir die recht umfangreiche schon erstellte Grafik aus dem letzten ggplot2-Beitrag.

Machen wir von Anfang an klar, welches Theme wir nutzen wollen:

1

g <- ggplot(mdat,aes(y=value,x=Jahr)) + theme_bw()

Hier verwenden wir nun anstatt color für die Färbung der Punkte einfach shape. Dies entspricht genau dem pch wie man es aus R kennt.

Für den Konfidenzintervall ist die Flächenfarbe (fill=) schwarz und die Farbe der Mittellinie (fill=) grau. Ich finde es übrigens sehr praktisch Farben in der Hex-Schreibweise einzugeben, da mit wenig Tipparbeit die Farbkomponenten festgelegt sind: #FFFFFF oder man sucht sich einfach eine schöne Farbe.
Das nur nebenbei. Wichtig ist die Angabe von alpha= der Undurchsichtigkeit des Geoms, da ansonsten alles tatsächlich schwarz wäre.

3
4
5

g <- g + geom_point(aes(shape=Probenart)) +
  stat_smooth(fill="black",color="#555555",alpha=0.1) +
  facet_wrap(~Analyt+Messeinheit, scales="free_y", ncol=1)

Im folgenden Schritt passen wir noch die vielen Optionen aus dem Ausgangsbeispiel an. Aus guides(color = ...) muss natürlich guides(shape = ...) werden, da wir ja nun die Legende für die Symbole (Shapes) modifizieren wollen.
Hinzu kommt noch - und das ist relativ wichtig - die Festlegung der shape-Scale via +scale_shape_manual(values=c(1,2,...)), denn unter der Standardeinstellung gibt es nur 6 verschiedene Symbole, alles drüber beleibt leer. Welche Zahl für welches Symbol steht ist wie bei den base graphics.

Welche Nummer liefert welches Symbol. Hier eine kleine Zuordnung. Wenn mann es mal schnell braucht einfach plot(0:25,1,pch=0:25) ausführen.

Alternativ kann man auch Irgendwelche Zeichen verwenden. Also scale_shape_manual(values=c("a","#","?",...)). Dann sollte jedoch mit geom_point(aes(...), size=2) die Zeichengröße etwas erhöht werden.

Das war es auch schon an Anpassungen, die vorgenommen werden müssen, um solch einen kopierfreundlichen Plot zu erzeugen.

7
8
9
10
11
12
13
14
15
16

g <- g + ylab(label="Wert") + 
  opts(legend.position="bottom", title="Bodenproben") + 
  guides(shape = guide_legend(ncol = 2,title.vjust=0.2)) +
  scale_shape_manual(values=c(21,22,23,24,25,3,8,4)) + 
  opts(legend.title=theme_text(angle=90, face="bold", size=11),
       plot.title=theme_text(face="bold", size=20,vjust=1)) +
       scale_x_continuous(minor_breaks = function(x){ceiling(x[1]):floor(x[2])},
                          breaks = function(x){seq(ceiling(x[1]),floor(x[2]),by=2)})
 
g

Farben und Schwarzweißdrucker

Ein farbiger Plot kann auch durchaus kopierbar sein. Leider ist das standard ggplot2-Farbschema weder besonders SW-Drucker-freundlich (alle Farben haben die gleiche Helligkeit) noch besonders gut lesbar für Farbenblinde. Wer sich für das Thema interessiert findet hier eine gute Informationsgrundlage. Es spricht häufig sicherlich nichts dagegen, sowohl Farben als auch Symbole zu verwenden, indem man in den Aesthetics beides festlegt (aes(shape=xy, color=xy)).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

stretchjoin <- function (dat, rep, schema, recycle=T) {
  i <- 1 #position in dat
  j <- 1 #position in 
  s <- 1 #position in schema
  f <- 1 #position in result
  res <- NULL
  fin <- FALSE
  while(!fin){
    if(schema[s]==T){
      res[f] <- dat[i]
      i <- i+1 #go to next item in dat
    }else{
      res[f] <- rep[j]
      j <- j+1 #go to next item in rep
    }
    s <- s+1 #go to next item in schema
    f <- f+1 #go to next item in result
    if(s>length(schema)){
      #if reached end of schema, start over 
      s <- 1
    }
    if(j>length(rep) & recycle){
      j <- 1 #if reached end of replacement vector and recycling allowed, start over
    }else if(schema[s]==F & j>length(rep) & !recycle){
      warning("Reached end of repment vector before end of dat. Set recycle=T!")
      fin <- T
    }
    if(i>length(dat) & schema[s]==T){
      #fin if reached end in dat an next item has to be from dat according to the schema
      fin <- T
    }
  }
  return(res)
}
 
#
# Examples
#
 
x <- 1:12
y <- NA
s <- c(T,T,T,T,T,F,F)
stretchjoin(x,y,s,T)
#[1]  1  2  3  4  5 NA NA  6  7  8  9 10 NA NA 11 12
 
x <- 1:15
y <- -(1:4)
stretchjoin(x,y,s,T)
#[1]  1  2  3  4  5 -1 -2  6  7  8  9 10 -3 -4 11 12 13 14 15 -1 -2

Mit den Ergebnissen als Indexvektor kann man dann auch einfach eine neue Matrix erzeugen. Naja ok. Ein wenig tricksen muss man schon:

mat1 <- matrix(runif(20), ncol=2)
mat2 <- matrix(-(1:2),ncol=2, nrow=2)
mat_neu <- rbind(mat1,mat2)
i1 <- stretchjoin(1:nrow(mat1), rep=nrow(mat1)+(1:nrow(mat2)) ,schema=c(T,T,T,F,F),recycle=T)
mat_neu <- mat_neu[i1,]
mat_neu
#        [,1]        [,2]
#  [1,]  0.39263009  0.53411873
#  [2,]  0.72839589  0.52903701
#  [3,]  0.82255067  0.01965311
#  [4,] -1.00000000 -1.00000000
#  [5,] -2.00000000 -2.00000000
#  [6,]  0.05864827  0.18895893
#  [7,]  0.38650819  0.23657343
#  [8,]  0.73526049  0.45979191
#  [9,] -1.00000000 -1.00000000
# [10,] -2.00000000 -2.00000000
# [11,]  0.46804821  0.93976568
# [12,]  0.20527319  0.31220657
# [13,]  0.25728071  0.84647837
# [14,] -1.00000000 -1.00000000
# [15,] -2.00000000 -2.00000000
# [16,]  0.33444153  0.93647087

Ich bin mir sicher, dass es dafür noch eine schönere Lösung gibt. Vor allem ist diese Lösung bei sehr großen Datensätzen vielleicht nicht die schnellste. Klüger ist es sicherlich direkt einen guten Indexvektor zu erzeugen und nicht mit den Daten zu hantieren. Eine solche Variante wird folgen.

Einen Datensatz entdecken

Aus der Umweltprobenbank habe ich mir mal diesen Datensatz zusammengestellt. Ich weiß auch nur, dass es um die Bodenbelastungen an verschiedenen Orten in Deutschland geht. Einen tieferen Einblick in die Daten gewinnt man mit bloßen Augen nicht so recht.

Ein kleiner Einblick mit Excel in den Datensatz

1
2
3

dat <- read.table("upb_chemical_pollution_data.csv", head=T, sep="\t", dec=",")
dat <- dat[dat$Statistischer.Parameter=="Arithmetischer Mittelwert",] #Wir interessiern uns nur für die Mittelwerte
head(dat)

Ein Blick auf den Anfang des Datensatzes verrät, dass R die Zahlen der Spaltennamen um ein vorangestelltes X erweitert hat. Das muss später noch bereinigt werden. Außerdem interessieren wir uns nur für die Zeilen, die den Arithmetischen Mittelwert der Messungen beinhalten (Zeile 2).

Daten umformen mit melt()

Wichtig für ggplot (wir erinnern uns) ist, dass jeder Punkt des Plots durch eine Zeile im Datensatz repräsentiert wird. Natürlich soll jedes Jahr ein eigenen Datenpunkt darstellen. Dazu muss für jede Zeile des Datensatzes der Bereich mit den Jahreszahlen transponiert werden, sodass die Jahreszahlen dann eine Spalte bilden. Die Werte aus der ursprünglichen Zeile gelten für alle Jahre, also werden sie in die neu entstandenen Zeilen kopiert. Das klingt kompliziert, aber mit der Funktion melt() aus dem Paket reshape() (Hinweis: In älteren Versionen von ggplot2 war melt() noch enthalten) geht es im nu.

5
6
7
8

mdat <- melt(dat, measure.vars=8:24, 
                  id.vars=c("Probenart","Analyt","Messeinheit"), 
                  variable_name="Jahr", na.rm=T)
head(mdat)

In den Spalten 8 bis 24 stehen die Jahre mit ihren Messwerten (measure.vars=8:24. Das sind also die Spalten die in Zeilen transponiert werden sollen. Der Name für die so neu entstandene Spalte ist mit variable_name="Jahr" festgelegt. Die jahresunabhänigen Merkmale die uns interessieren sind gegeben durch id.vars=c("Probenart","Analyt","Messeinheit"). Ist ein Messwert nicht vorhanden, so soll keine Zeile enstehen (na.rm=T).

Hinweis zu melt(): In der Regel genügt die Angabe von id.vars= oder measure.vars=. Es werden dann jeweils die übrigen anderen Spalten als measure.vars bzw. id.vars verwendet. Angaben können sowohl über Spaltenindizes als auch über Spaltennamen erfolgen.

Nun noch schnell das X vor der Jahreszahl entfernen:

9

mdat$Jahr <- as.numeric(substr(mdat$Jahr,start=2,stop=5)) #nur Zeichen 2 bis 5 werden genommen

Nun lassen wir die Magie passieren:

11
12

g <- ggplot(mdat,aes(y=value,x=Jahr))
g  + geom_point(aes(color=Probenart))

Gut – das war sehr basic. Bereits hier erkennt man, dass in Regenwürmern der Wert der Schadstoffkonzentration sehr hoch ist. Sie scheinen sich also gut zu eignen um Schadstoffe im Boden ausfindig zu machen. Interessant! Also das Leute das überhaut machen.
Jetzt stellt sich die Frage: Lässt sich denn ein Trend erkennen? Wie wäre es mit einer polynomiellen Regression?

14
15

g + geom_point(aes(color=Probenart)) + 
    stat_smooth()

Hat sich der Schadstoffanteil im Boden also seit 1995 verbessert? Das ist alles noch ein wenig undifferenziert. Wir sollten die Regression nach den verschiedenen Schadstoffen unterteilen.

17
18

g + geom_point(aes(color=Probenart)) +
    stat_smooth(aes(group=Analyt, fill=Analyt),color="black")

Ok – offensichtlich wurde der Regenwurm genutzt um den Phosphorgehalt in Boden zu untersuchen. Schwefel wurde wohl im Eiinhalt einer Stadttaube untersucht. Das ist aber sehr Vage formuliert. Wie wäre es denn mit verschiedenen Plots für die unterschiedlichen Stoffe? Das geht mit Hilve von facet_wrap(). Durch die Einteilungen kann auch die Gruppierung bei stat_smooth() weglassen werden. Da die Schadstoffkonzentrationen unterschiedlich gelegen sind darf bei jedem Abschnitt die y-Achse frei sein (scales="free_y"). Mit ncol=1 wird bewirkt, dass die Plots untereinander erscheinen. Darum habe ich auch nicht scales="free" gewählt, denn so bleiben die Jahre richtig untereinander.

20
21
22
23

g <- g + geom_point(aes(color=Probenart)) +
	 stat_smooth() +
         facet_wrap(~Analyt+Messeinheit, scales="free_y", ncol=1)
g

Das ist doch schon viel übersichtlicher. Da ich mit den Geoms in diesem Plot schon recht zufrieden war hab ich alles mal fest im ggplot-Objekt gespeichert. Denn nun widmen wir uns dem Layout.

Layout eines ggplot-Plots verändern

Jetzt mache ich es mal kurz: Das Ergebnis, der Code und danach die Erläuterung:

25
26
27
28
29
30
31

g + ylab(label="Wert") + 
	  opts(legend.position="bottom", title="Bodenproben") + 
	  guides(color = guide_legend(ncol = 2,title.vjust=0.2)) +
	  opts(legend.title=theme_text(angle=90, face="bold", size=11),
		plot.title=theme_text(face="bold", size=20,vjust=1)) +
	  scale_x_continuous(minor_breaks = function(x){ceiling(x[1]):floor(x[2])},
	                     breaks = function(x){seq(ceiling(x[1]),floor(x[2]),by=2)})

• 25: Der Name der y-Achse wird geändert und es wird eine Überschrift hinzugefügt.
• 26: Wir positionieren die Legende nach unten uns geben ihr einen neuen Titel.
• 27: Die Gestaltungsführung guides() der Farblegende (color=guide_legend()) wird auf 2 Spalten (ncol = 2) geändert und der Titel ein wenig nach oben verschoben (title.vjust=0.2).
• 28: In den ggplot-Optionen (opts()) wird der Titel der Legende um 90° gedreht, auf Schriftgröße 11 und dick gedruckt gesetzt.
• 29: Des weiteren passen wir auch die Schriftart der Überschrift an.
• 30: Das feine x-Achsengitter wird auf ganze Jahre gelegt …
• 31: und das grobe Gitter auf alle zwei Jahre.

Fertig!

Die Vorteile von ggplot2:

• schönere Optik
• Grafiken können leicht an neue Bedürfnisse angepasst werden
• Exploration von Daten mit wenig Code und bereits druckfertigen Ergebnissen
• Erscheinungsbild mit wenig Code sauber veränderbar
• Viele bereits mitgelieferte Plot-typen

Nachteile:

• gewisse Einarbeitungszeit
• Daten für ggplot2 Vorbereiten manchmal unintuitiv

Zuerst sollte man verstehen, wie die Daten vorliegen sollten, damit ggplot seine Arbeit zuverlässig tut. Dazu folgender Grundsatz:

Jeder Datenpunkt eine Zeile!

In einem data.frame (es muss immer ein data.frame sein) muss jede Zeile einen Datenpunkt in unserem Plot widerspiegeln. Wenn also zu einem Merkmalsträger mehrere Daten vorliegen die auf einer Achse liegen sollen haben wir zunächst einmal ein kleines Problem. Dazu aber später mehr.
Wenn also jede Zeile einen Datenpunkt enthält, welche Spalten soll es denn geben? Hier liegen die großen Stärken von ggplot2: Fast jeder Spalte kann eine “grafische Interpretation” zugewiesen werden. Betrachten wir folgendes Beispiel:

Hier ein Beispieldatensatz und wie wir ihn darstellen wollen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

install.packages("ggplot2") # Installiert das Packet 
library("ggplot2") # Lädt das Packet
 
staedte <- "Stadt;Einwohner;Fläche in km2;Schulden in Mrd;Regierung
Berlin;3499879;891,85;64,03;SPD und CDU
Dortmund;580444;280,71;2,16;SPD
München;1353186;310,43;0;SPD
Hamburg;1799144;755,264;24,9;SPD
Stuttgart;606588;207,36;2,8;CDU"
 
stadtdaten <- read.table(textConnection(staedte), sep=";", head=T, dec=",")
head(stadtdaten)
# Wir sehen, dass die Spaltennamen keine Leerzeichen mehr enthalten.
# Die Spaltennamen sind gleich noch wichtig.

Bis hierhin alles also recht klar. Nun kommen wir dorthin, wo die Magie geschieht:

16
17
18
19
20

g <- ggplot(stadtdaten, 
            aes(x=Einwohner, 
                y=Fläche.in.km2, 
                size=Schulden.in.Mrd, 
                color=Regierung))

Was geschieht hier? g wird das neue ggplot-Objekt. Hier kommt alles rein, was wir plotten wollen. Initialisiert wird es stets mit ggplot(). Meistens wird man jedoch noch zwei Parameter angeben: An erster Stelle steht der Datensatz (hier: stadtdaten), aus dem ggplot die Informationen ziehen soll. Das zweite Argument ist die Funktion aes(). Diese wertet jede Zeile des Datensatzes aus und ihr kann wiederum vorgegeben werden, welche Spalte wie dargestellt werden soll. Die Nutzung von aes() stellt auch die Beschriftung der Achsen und der Legende sicher.
Jetzt muss dem ggplot Objekt noch gesagt werden, wie es zu plotten ist. Am sinnvollsten erscheint es die Daten als Punkte darzustellen:

21
22

g <- g + geom_point()
g

geom_point() muss kein weiteres Argument übergeben werden, da bereits alle notwendigen Angaben durch aes() in g stehen. Da g jetzt weiß, wie es zu plotten ist können wir es einfach mit dem Aufruf g plotten.
So sieht das Ergebnis aus:

Noch nicht besonders toll. Die Punkte sind viel zu klein und zuerst einmal würden wir gerne wissen welche Stadt nun welcher Punkt ist. Das ist überhaupt kein Problem! geom_text() macht alles.

24
25

g + geom_text(aes(label=Stadt))
g

Wir erinnern uns: g wurden bereits gesagt, dass es ein Punkteplot werden soll. Jetzt kommt das so genannte Geom (geometric object) geom_text() hinzu. Das Geom braucht jedoch zwingend noch ein Argument, welches ihm sagt, welcher Text denn jeweils gedruckt werden soll. Dieses regelt wieder aes().
Doch was ist nun passiert?!

Wie bereits erwähnt gilt das ganz am Anfang in ggplot() geschriebene aes() für alle Dinge die zu g hinzugefügt werden. Und so bedient sich auch das geom_text() der Farben und Größen, welche wir anfangs bestimmt haben. Häufig wollen wir das auch. Zumindest für die x und y-Koordinaten und hier vielleicht auch für die Farbe. Also müssen wir die Eigenschaften trennen, je nachdem ob sie mit zum Text oder zu den Punkten gehören sollen und nur die gemeinsamen Eigenschaften schreiben wir in die allgemeinen Aesthetics (aes()).
Also noch mal von vorn:

27
28
29
30
31
32

g2 <- ggplot(stadtdaten,
             aes(x=Einwohner, 
                 y=Fläche.in.km2,
                 color=Regierung))
g2 <- g2 + geom_point(aes(size=Schulden.in.Mrd))
g2 + geom_text(aes(label=Stadt))

Immer noch nicht das Gelbe vom Ei. Die Schrift braucht rechts und links irgendwie mehr Platz. Das geht wie folgt:

34
35
36

g2 <- g2 + scale_x_continuous(expand=c(0.2,0)) +
           scale_y_continuous(expand=c(0,60))
g2 + geom_text(aes(label=Stadt))

Nun haben wir die x-Achse links und rechts um 20% ihrer ursprünglichen Breite erweitert. Die y-Achse geht nun 60 Einheiten weiter nach oben und unten. Man kann in expand() auch beides Kombinieren. Die erste Zahl ist ein Faktor und die zweite eine Konstante.

Immer noch nicht perfekt. Der Text sollte nicht so auf den Punkten kleben.

38

g2 + geom_text(aes(label=Stadt),vjust=-0.6)

Wichtig ist zu beachten, dass vjust und hjust offiziell nur die Werte 0,0.5,1 unterstützt. Mehr Möglichkeiten zum modifizieren des Text-Geoms findet man auf der offiziellen ggplot2 Hilfe.

So sieht es doch schon fast brauchbar aus. Jetzt wäre es jedoch super, wenn die Skalen etwas schöner wären und überhaupt alles:

40
41
42
43

g2 <- g2 + scale_y_continuous(trans="log2", expand=c(0,0.22)) +
  #mit trans funktioniert expand etwas merkwürdig, neuanpassung notwendig
           scale_size_continuous(trans="sqrt",range=c(3,10), breaks=c(0,10,30,60))
g2 + geom_text(aes(label=Stadt,vjust=-0.5-sqrt(Schulden.in.Mrd/80)))

Mit trans="" können die Achsen transformiert werden. Das Schöne ist, dass auch die Koordinatengitter sich anpasst, sodass die Transformation auf den ersten Blick sichtbar ist. Mögliche Transformationen sind u.a: log, log2, sqrt, exp, log10.
Mit scale_size_continuous() wird die Größenskala angepasst. trans="log" kann hier nicht verwendet werden, da München nicht verschuldet ist. Mit range=c(3,10) wird festgelegt, dass der kleinste Punkt die Größe 3 und der größte die Größe 10 haben soll. breaks=c(0,10,30,60) lässt uns die Möglichkeit manuell anzugeben, welche Größen in die Legende gepackt werden. Oft liefert da die Automatik von ggplot nicht die besten Ergebnisse.
Ein kleiner Trick ist auch in geom_text() enthalten: Wichtig ist zu merken, dass bei ggplot fast alle Plottingeigenschaften sowohl in den Aesthetics als auch außerhalb stehen können. Stehen sie Außerhalb gelten sie für alle Elemente des Geoms pauschal und werden nicht in die Legende übernommen. Innerhalb von aes() werden sie für jede Zeile in dem Datensatz angewendet. Wenn man dies Verinnerlicht hat man schon eine der wichtigsten ggplot-Eigenschaften verstanden und kann damit gut arbeiten. In diesem Beispiel heben wir so den Text abhängig von der jeweiligen Punktgröße (die Schulden) weiter über die ursprüngliche Position.

Auch wenn das jetzt viel Text war, hoffe ich, dass ihr die Grundsätze von ggplot2 verstanden habt und somit auch die sehr hilfreichen und zahlreichen Beispiele auf der offiziellen Seite besser nachvollziehen könnt.

Coefficients:
(Intercept) Girth Volume
83.2958 -1.8615 0.5756


Ich werde kurz zeigen wie mit apply() Matrizen und data.frames zeilen- sowie spaltenweise Ausgewertet werden können. Nach dieser sehr leichten Übung widmen wir uns einem etwas trickreicherem Beispiel, in dem wir mehrere gleichartige Tabellen (also Matrizen bzw. data.frames) der gleichen Zeilen- und Spaltenanzahl vorliegen haben. Hier möchten wir die Informationen aus immer den gleichen Zellen zusammenfassen.

apply auf einer Matrix

Wer lapply() verstanden hat, der wird auch hiermit kein Problem haben.
apply(X, MARGIN, FUN, ...)
X ist eine Matrix oder ein data.frame
MARGIN gibt an, ob jede Zeile MARGIN=1 transponiert als Vektor der Funktion übergeben werden soll oder jede Spalte MARGIN=2 an die Funktion (FUN) übergeben wird. Es gibt noch weitere Möglichkeiten – dazu später.

Einfache Beispiele:

1
2
3
4
5
6
7
8
9
10
11

USPersonalExpenditure
#                      1940   1945  1950 1955  1960
#Food and Tobacco    22.200 44.500 59.60 73.2 86.80
#Household Operation 10.500 15.500 29.00 36.5 46.20
#Medical and Health   3.530  5.760  9.71 14.0 21.10
#Personal Care        1.040  1.980  2.45  3.4  5.40
#Private Education    0.341  0.974  1.80  2.6  3.6
 
apply(USPersonalExpenditure,2,sum)
#  1940    1945    1950    1955    1960 
#37.611  68.714 102.560 129.700 163.140

Aus den Ausgaben der US-Bürger in Milliarden USD in den verschiedenen Kategorien, haben wir jetzt also berechnet, wie viele Milliarden sie in den Kategorien zusammen ausgegeben Haben.

Finden wir nun heraus, wie die Steigerung zum Vorjahr ausfällt. Dazu müssen wir die Daten natürlich Zeilenweise auswerten.

13
14
15
16
17
18
19
20
21
22
23

apply(USPersonalExpenditure,1,function(x){
	n <- length(x)
	ratio <- x[2:n]/x[1:(n-1)]
	res <- c('1940'=NA,round(ratio,2))
})
#      Food and Tobacco Household Operation Medical and Health Personal Care Private Education
# 1940               NA                  NA                 NA            NA                NA
# 1945             2.00                1.48               1.63          1.90              2.86
# 1950             1.34                1.87               1.69          1.24              1.85
# 1955             1.23                1.26               1.44          1.39              1.44
# 1960             1.19                1.27               1.51          1.59              1.40

Hier sieht man auch sehr gut, dass apply() die Funktionsergebnisse (hier Vektoren) wieder schön in einer Matrix zusammenfasst, wenn es dazu in der Lage ist.

apply() hoch 3

Schauen wir uns einmal so eine “dreidimensionale” Tabelle an.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

HairEyeColor
# , , Sex = Male
# 
# Eye
# Hair    Brown Blue Hazel Green
# Black    32   11    10     3
# Brown    53   50    25    15
# Red      10   10     7     7
# Blond     3   30     5     8
# 
# , , Sex = Female
# 
# Eye
# Hair    Brown Blue Hazel Green
# Black    36    9     5     2
# Brown    66   34    29    14
# Red      16    7     7     7
# Blond     4   64     5     8

Auch hier funktioniert apply() wie geschmiert.
Wie oft kommt welche Haarfarbe vor?

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#Wie oft kommt welche Haarfarbe vor?
apply(HairEyeColor,1,sum)
#Black Brown   Red Blond 
#  108   286    71   127 
 
#Wie oft welche Augenfarbe?
apply(HairEyeColor,2,sum)
#Brown  Blue Hazel Green 
#  220   215    93    64
 
#Die Tabelle für beide Geschlechter zusammengefasst:
apply(HairEyeColor,1:2,sum)
#        Eye
# Hair    Brown Blue Hazel Green
# Black    68   20    15     5
# Brown   119   84    54    29
# Red      26   17    14    14
# Blond     7   94    10    16

Wieso MARGIN=c(1,2)? Man kann sich das ganz einfach so vorstellen: Für die Erzeugung des Vektors, welcher an die Funktion übergeben wird, bleibt jeweils die Zeile (1) und die Spalte (2) fest. In der dritten Dimension ist also “frei”. Im zweidimensionalen Fall ist es genau so.

Wenn man es verinnerlicht hat, sollte man sich auch denken können, was folgende Aufrufe erzeugen? Was denkst du?

38
39

apply(HairEyeColor,c(1,3),sum)
apply(HairEyeColor,2:3,sum)

Außer für solch einfache Beispiele kann das auch von Nutzen sein um evtl. die Varianz eines Wertes in einer Kontingenztafel zu berechnen, wenn mehrere solcher Tafeln vorliegen. So kann es vorkommen, dass man mehrere Kontingenztafel simuliert und sich dann für die Streuung der Werte in den einzelnen Zellen interessiert.

Wie erzeugt man solch dreidimensionale Tabellen?

Ganz einfach z.B. mit table():

1

table(mtcars[,c("am","gear","cyl")])

Etwas komplizierter, eine kleine Simulationsstudie zu Vierfeldertafeln.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

ktafeln <- replicate(1000, table(runif(10)>0.5,runif(10)>0.5))
 
tafArray <- function(taflist){
	#Konvertiert eine Liste von Matrizen mit gleichen Dimensionen (AxB) ein einen 3D-Array
	#Baut die 3te Dimension nacheinander auf.
	dimension <- c(dim(taflist[[1]]),1) #Die Dimension ist jetzt also (AxBx1)
	Array <- array(taflist[[1]], dim=dimension)
	for(i in 2:length(taflist)){
		dimension <- dimension + c(0,0,1)
		#Füge neue Matrix an (AxBxi)
		Array <- array(c(Array,taflist[[i]]),dim=dimension)
	}
	return(Array)
}
 
matrix3d <- tafArray(ktafeln)
res <- apply(matrix3d,1:2,function(x) quantile(x, probs=c(0.05,0.95)))
res #nicht so übersichtlich
aperm(res,c(2,3,1)) #Stellt die Quantile an letzte Stelle der Dimensionen
#, , 5%
#
#     [,1] [,2]
#[1,]    0    1
#[2,]    0    0
#
#, , 95%
#
#     [,1] [,2]
#[1,]    5    5
#[2,]    5    5

Das sind natürlich keine Konfidenzintervalle an denen sich etwas testen ließe. Nur eine Spielerei und zur Verdeutlichung.