elementare Datenverarbeitung

Vektoren

Begriff

Im Kontext von R ist ein Vektor als eine sequentiell geordnete Menge von Werten und nicht als das gleichnamige mathematische Konzept zu verstehen.

Vektoren erzeugen

Leere Vektoren eines bestimmten Typs lassen sich mit dem Namen des Typs als Funktion und der Anzahl der gewünschten Stellen als Argument erstellen. z.B.:

numeric(5);
character(4);
logical(3);

## [1] 0 0 0 0 0
## [1] "" "" "" ""
## [1] FALSE FALSE FALSE

Um mehrere Daten in einer eindimensinalen Anordnung zu verketten wird die c()-Funktion benutzt. Die Argumente werden in Reihenfolge der Eingabe hintereinander angeordnet und können beliebigen Datentypen angehören.

c(1,2,3,4);
c('dies', 'ist', 'ein', 'Vektor');
c(T, F, T, F);

## [1] 1 2 3 4
## [1] "dies"   "ist"    "ein"    "Vektor"
## [1]  TRUE FALSE  TRUE FALSE

Das Ergebnis kann dann wie gewohnt in ein Objekt abgelegt werden.

numericVector <-c(4,2,4242,42)

Außerdem lassen sich mit dem c()-Operator mehrere Vektoren kombinieren.

additionToNumericVector <-  c(424242, 42400, 42000,
                               4224, 24)
(numericVector <- c(numericVector, 
                    additionToNumericVector))

## [1]      4      2   4242     42 424242  42400  42000
## [8]   4224     24

Vektoren verwenden

Die Länge eines Vektors lässt sich mit der Funktion length() ausgeben.

length(numericVector)

## [1] 9

Datentypen in Vektoren

Bei dem Versuch Vektoren aus verschiedenen Datentypen anzulegen werden die Daten in den allgemeinsten Datentyp umgewandelt. Dabei gilt im Rahmen der Komplexität für die bisher vorgestellten Datentypen:

logical < numeric < character

mode(c(T, T, F));
mode(c(T, T, 0));
mode(c(T, 0, 'false'));

## [1] "logical"
## [1] "numeric"
## [1] "character"

In einem Vektor ist im Allgemeinen also immer nur ein Typ an Daten vertreten.

Aufgabe

Wenn ich mode(c('TRUE',FALSE,1)) eingebe, dann…

… wird logical ausgegeben
… wird vector ausgegeben
… wird numerical ausgegeben
… wird character ausgegeben

Indizierung

Elemente indizieren

Die beim Erstellen eines Vektors angelegten Positionen der Werte werden in R implizit mit fortlaufenden Indizes versehen und gespeichert. Diese Indizes starten bei jedem Vektor mit 1 und enden mit der Länge desselben. Die einzelnen Elemente eines Vektors lassen sich über ihren Index mit dem [] - Operator aufrufen.

numericVector[4] ## 4. Element des Vektors numericVector.

## [1] 42

Wird ein Index über dem des letzten Eintrags eines Vektors aufgerufen, wird NA zurückgegeben.

numericVector[length(numericVector)+1]

## [1] NA

mehrere Elemente gleichzeitig indizieren

Es lassen sich auch mehrere Werte eines Vektors über die Indizierung über Zuhilfenahme eines anderen Vektors aufrufen. Dabei kann der Index-Vektor als Objekt vordefiniert oder dem []-Operator direkt übergeben werden.

idx <- c(1,2,3,8)
numericVector[idx]

## [1]    4    2 4242 4224

numericVector[c(4,5,6,7)]

## [1]     42 424242  42400  42000

Der Index-Vektor kann dabei auch länger als der ursprüngliche Vektor sein, da mehrfacher Aufruf eines Index möglich ist.

numericVector ## 9 Werte

## [1]      4      2   4242     42 424242  42400  42000
## [8]   4224     24

idx <- c(1,1,2,2,3,3,4,4,5,5,6,6)
## 12 Aufrufe über die Indizes
numericVector[idx]

##  [1]      4      4      2      2   4242   4242     42
##  [8]     42 424242 424242  42400  42400

Elemente ausschließen

Durch das verwenden negativer Indizes wird das entsprechende Element von der Ausgabe ausgeschlossen.

numericVector[-3] ## Vektor ohne drittes Element

## [1]      4      2     42 424242  42400  42000   4224
## [8]     24

idx <- c(1,3,5,7,9)
## Vektor mit Ausnahme der in idx abgelegten Indizes:
numericVector[-idx]

## [1]     2    42 42400  4224

Elemente austauschen

Die Indizierung kann außerdem genutzt werden um Elemente eines Vektors zu ersetzen oder als alternative Methode zu oben vorgestelltem Kombinieren von Vektoren via c(<Vektor1>, <Vektor2>).

numericVector

## [1]      4      2   4242     42 424242  42400  42000
## [8]   4224     24

numericVector[1] <- 12
numericVector

## [1]     12      2   4242     42 424242  42400  42000
## [8]   4224     24

numericVector[idx] <-idx
numericVector

## [1]     1     2     3    42     5 42400     7  4224
## [9]     9

length(numericVector)

## [1] 9

numericVector[c(10,11,12,13,14)] <- idx
numericVector

##  [1]     1     2     3    42     5 42400     7  4224
##  [9]     9     1     3     5     7     9

Elemente löschen

Elemente eines Vektors lassen sich nicht im eigentlichen Sinne löschen, man kann aber sehr wohl das Objekt in dem der Vektor abgelegt ist mit einer verkürzten Version überschreiben.

numericVector <- numericVector[-idx]
numericVector

## [1]     2    42 42400  4224     1     3     5     7
## [9]     9

Logische Operatoren

Verarbeitungsschritte mit logischen Operatoren treten häufig bei der Auswahl von Teilmengen von Daten sowie der Recodierung von Datenwerten auf, zwei häufigen Prozeduren in der statistischen Auswertung

Logischer Vergleich von Vektoren

Wie vorher Einzelwerte kann man auch Vektoren in logischen Vergleichen verwenden.

age <- c(17, 30, 30, 24, 23, 21)
age < 24

## [1]  TRUE FALSE FALSE FALSE  TRUE  TRUE

age >= 18

## [1] FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

Dabei werden logische Werte als Ergebnis für den Vergleich jeden Wertes ausgegeben.

Die vorher gezeigten logischen Verknüpfungen lassen sich genauso anwenden

 ## Alle Werte die mindestens 18 und kleiner als 30 sind
(age >= 18) & (age < 30)

## [1] FALSE FALSE FALSE  TRUE  TRUE  TRUE

## Alle Werte die kleiner als 18 oder mindestens 30 sind
(age < 18) | (age >= 30)

## [1]  TRUE  TRUE  TRUE FALSE FALSE FALSE

Logische Vektoren

Die mit sum() gebildete Summe eines logischen Vektors gibt einem die Anzahl der wahren Werte im Vektor aus, da TRUE für die Berechnung in eine 1 und FALSE in eine 0 transformiert wird.

res <- !((age < 18) | (age >= 30))
sum(res)

## [1] 3

Logische Vergeiche von Vektoren

Zwei gleichlange Vektoren lassen sich auch mit Hilfe logischer Operatoren vergleichen.

age2 <- c(19, 31, 29, 24, 30, 22)
age == age2

## [1] FALSE FALSE FALSE  TRUE FALSE FALSE

Und natürlich lassen sich hier alle vorher besprochenen logischen Operatoren anwenden:

age == age2

## [1] FALSE FALSE FALSE  TRUE FALSE FALSE

age < age2

## [1]  TRUE  TRUE FALSE FALSE  TRUE  TRUE

age != age2

## [1]  TRUE  TRUE  TRUE FALSE  TRUE  TRUE

Logische Indizierung

Indizierung funktioniert auch mit logischen Vektoren. Dabei wird im Indexvektor für jeden Wert des indizierten Vektors angegeben, ob dieser ausgewählt derden soll oder nicht. Eine einfach Methode zur Auswahl von Teilmengen von Elementen die einem bestimmten Kriterium entsprechen.

(res <- age < 24)

## [1]  TRUE FALSE FALSE FALSE  TRUE  TRUE

age[res]

## [1] 17 23 21

Der Indexvektor muss nicht vorher als Objekt angelegt werden.

age[age<24]

## [1] 17 23 21

Logische Indizierung und fehlende Werte

Versucht man Vektoren mit fehlenden Werten zu erzeugen, stößt man auf folgendes Problem:

age3 <-  c(20, 23, 32, NA, 19, 27)
(idx <- age3 < 24)

## [1]  TRUE  TRUE FALSE    NA  TRUE FALSE

age3[idx]

## [1] 20 23 NA 19

Umgang mit fehlenden Werten bei logischer Indizierung

Der fehlende Wert wird in den Index-Vektor und die Indizierung weitergetragen.
Umgehen lässt sich dieses Problem mit der which()-Funktion, die die Positionen aller TRUE-Werte des ihre übergebenen Arguments als numerischen Vektor ausgibt.

(idx <- which(idx))

## [1] 1 2 5

Dieser kann dann wieder zur Indexierung benutzt werden.

age3[idx]

## [1] 20 23 19

Systematische Wertefolgen erzeugen

Numerische Sequenzen erstellen

In R lassen sich durch einen Doppelpunkt Zahlensequenzen in Einserschritten zwischen einem Start- und Endwert erstellen.

1:20 
20:1
-10:10
-(1:20)

##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16
## [17] 17 18 19 20
##  [1] 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5
## [17]  4  3  2  1
##  [1] -10  -9  -8  -7  -6  -5  -4  -3  -2  -1   0   1
## [13]   2   3   4   5   6   7   8   9  10
##  [1]  -1  -2  -3  -4  -5  -6  -7  -8  -9 -10 -11 -12
## [13] -13 -14 -15 -16 -17 -18 -19 -20

Sequenzen mit anderen Schrittgrößen lassen sich mit der seq()-Funktion erstellen.

Dabei lässt sich entweder die Schrittgröße angeben:

seq(from = 0, to = 42, by = 6)

## [1]  0  6 12 18 24 30 36 42

seq(from = 0, to = 42, by = 5) ## Endpunkt nicht erreicht

## [1]  0  5 10 15 20 25 30 35 40

Oder die gewünschte Anzahl der Werte in der Sequenz:

seq(from = 0, to = 42, length.out = 8)

## [1]  0  6 12 18 24 30 36 42

seq(from = 0, to = 42, length.out = 6)

## [1]  0.0  8.4 16.8 25.2 33.6 42.0

Bei zweiterer Methode oder bei Angabe einer nicht-ganzzahligen Schrittgröße können auch nicht zur Indizierung geeignete Dezimalzahlen entstehen.

seq(from = 0, to = 1, by = 0.1)

##  [1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

Mit dem along Argument lässt sich außerdem eine Sequenz in der Länge eines übergebenen Vektors erstellen.

age <-c(16, 43, 30, 22,  7, 36)
seq(along = age)

## [1] 1 2 3 4 5 6

seq(from = 10, to = 100, along = age)

## [1]  10  28  46  64  82 100

Wertefolgen wiederholen

someValues <- c(42, 16, 12)
 ## Vektor 5-mal wiederholen
rep(someValues, times = 5)

##  [1] 42 16 12 42 16 12 42 16 12 42 16 12 42 16 12

 ## Jeden Wert des Vektors 5 mal wiederholen
rep(someValues, each = 5)

##  [1] 42 42 42 42 42 16 16 16 16 16 12 12 12 12 12

 ## Jeden Wert so oft wie in times individuell angegeben wiederholen
rep(someValues, times = c(42, 1, 5))

##  [1] 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42
## [17] 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42
## [33] 42 42 42 42 42 42 42 42 42 42 16 12 12 12 12 12

Daten transformieren

Werte sortieren

sort() sortiert je nach Angabe in auf- oder absteigender Reihenfolge

sort(someValues, decreasing = FALSE)

## [1] 12 16 42

sort(someValues, decreasing = TRUE)

## [1] 42 16 12

order() macht im Prinzip dasselbe, gibt aber statt des sortierten Vektors die Indizes in entsprechender Ordnung aus.

someValues

## [1] 42 16 12

(idx <- order(someValues, decreasing = F))

## [1] 3 2 1

someValues[idx]

## [1] 12 16 42

Dies funktioniert auch für character-Vektoren in alphabetischer Ordnung

(someCharacters <-  c("Z", "D", "L", "O", "l", "n", "e", "N", "t", "R"))

##  [1] "Z" "D" "L" "O" "l" "n" "e" "N" "t" "R"

sort(someCharacters, decreasing = F)

##  [1] "D" "e" "l" "L" "n" "N" "O" "R" "t" "Z"

Sind Zahlen an der ersten Stelle in character-Vektoren vertreten, werden diese vor das Alphabet sortiert.

someCharacters <- c(
  "42 is fairly overused",
  "India",
  "Zulu",
  "Whiskey",
  "42",
  "a string of characters",
  "Tango",
  "not a number",
  "1"
)
sort(someCharacters, decreasing = F)

## [1] "1"                      "42"                    
## [3] "42 is fairly overused"  "a string of characters"
## [5] "India"                  "not a number"          
## [7] "Tango"                  "Whiskey"               
## [9] "Zulu"

Einfache deskriptiv-statistische Kennwerte

age <- c(6, 60, 44, 56, 8, 58, 87, 8, 55, 83)
IQ <- c(91, 104, 109, 92, 90, 101, 99, 93, 89, 118)

mean(age)  ## Mittelwert
var(age)  ## Varianz (korrigiert)
sd(age) ## Streuung (korrigiert)

## [1] 46.5
## [1] 895.6111
## [1] 29.92676

N <- length(age)
sd(age)/sqrt(N) ## SEM

## [1] 9.463673

sqrt((N-1) / N) * sd(age) ## unkorrigierte Streuung

## [1] 28.39102

cov(x=age, y=IQ, method="pearson")  ## Kovarianz

## [1] 167.6667

cor(x=age, y=IQ, method="pearson")  ## Korrelation

## [1] 0.5875238