“Math is a language that you use to describe statistics, but really it’s about collecting information and putting in in an order that makes sense” - Lauren Stamile


Functies

De belangrijkste functie in R is de c(): “Combine functie”. Hiermee wordt data gebundeld in een object: de vector. c() is veelzijdig en kan verschillende datatypes binden. Het is echter alleen in staat om 1 datatype per keer te combineren in een vector. c() kan ook gebruikt worden om bestaande objecten aan elkaar te binden tot een nieuw object.

# maak een nieuwe variabele genaamd x
x <- c(1,2,3,4)
# print de output van x
x 
## [1] 1 2 3 4
# Maak variabele y bestaande uit de getallen '5 t/m 10'
y <- c(5:10,NA)
# print de output van y
y   
## [1]  5  6  7  8  9 10 NA
# Maak variabele z bestaande uit variabelen x en y.
z <- c(x,y) 
# geef de output van z zonder print()
z
##  [1]  1  2  3  4  5  6  7  8  9 10 NA

Data types

R kent verschillende type objecten. Een vector is een enkele reeks van variabelen. Een matrix is een reeks variabelen in een 2-dimensionale structuur: een tabel met een gelijk aantal kolommen en rijen. Factoren bestaan uit een reeks categoriale elementen met een gefixeerd aantal mogelijkheden (bv man of vrouw). Een data.frame is een tabel voor het aggregreren van verschillende type objecten en basic data types. List is een alles-in-een object; hier kunnen vectoren, matrixen, data.frames en lists in worden opgeslaan. Lees meer.

De belangrijkste data types zijn vectoren en data.frames. Deze worden het meest gebruikt in R.

Let op: R is hoofdlettergevoelig: ‘ABC’, ‘Abc’, en ‘abc’ zijn drie verschillende objecten.

Vector

Een vector is een reeks objecten van één basis datatype: numeriek, logical en character. De delen van een vector worden components genoemd. Vectoren worden gemaakt met de c() functie. Om sequentie components te maken, maak je gebruik van het : symbool. Voor een korte (7min) introductie zie deze Youtube Tutorial.

# Een numeric vector
x <- c(3, 1, 4)                   
x; class(x)
## [1] 3 1 4
## [1] "numeric"
# Vector van een numerieke sequentie van 1 tot en met 5
y <- c(1:5)                       
x
## [1] 3 1 4
# Een logical vector
x <- c(TRUE, FALSE, TRUE)         # Een logical vector met TRUE en FALSE
class(x)
## [1] "logical"
x <- c(F,F,T)                     # Een logical vector met T en F
x
## [1] FALSE FALSE  TRUE
# Een vector van characters
y <- c("aa", "bb", "cc")          
y
## [1] "aa" "bb" "cc"
class(y)
## [1] "character"
# Een vector is ook te maken met andere functies, bijvoorbeeld seq()
z <- seq(1 ,5, by=.5)             # vector van 1 t/m 5 met tussenstappen van 0.5
y
## [1] "aa" "bb" "cc"
# Met de functie length() kun je de hoeveelheid componenten in een vector oproepen
length(z)
## [1] 9
# Vectoren kunnen worden verbonden met de functie c()
x <- c(1, 2, 3) 
y <- c("aa", "bb") 
z <- c(x, y)                     
y
## [1] "aa" "bb"
# Hierdoor worden de getallen wel geforceerd als 'vrije tekst'. Een vector kan maar 1 datatype bevatten
class(z)
## [1] "character"

Matrix

Een matrix kun je maken met de matrix() function. De input voor deze functie bestaat uit een vector (de data), het aantal rijen (nrow) en het aantal kollomen (ncol) en hoe de data gesorteerd moet worden (byrow). De functies cbind() (kolom bij kolom) en rbind() (rij bij rij) worden gebruikt om vectoren om te zetten naar een matrix. De dimensies van een matrix zijn op te roepen met de functies: dim(), nrow() en ncol().

# Maak een vector en converteer deze naar een matrix
x <- c(1:20)
y <- matrix(data = x, nrow = 5, ncol = 4, byrow = TRUE)
y
##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12
## [4,]   13   14   15   16
## [5,]   17   18   19   20
# Roep de dimensies van het object 'data' op.
dim(y); nrow(y); ncol(y)
## [1] 5 4
## [1] 5
## [1] 4
# Gebruik de cbind() en rbind() functie om vectoren te bundelen in een matrix.
x <- c(1:5)
y <- c(6:10)
cbind(x,y)
##      x  y
## [1,] 1  6
## [2,] 2  7
## [3,] 3  8
## [4,] 4  9
## [5,] 5 10
rbind(x,y)
##   [,1] [,2] [,3] [,4] [,5]
## x    1    2    3    4    5
## y    6    7    8    9   10

Matrix index

Om componenten op roepen uit een matrix kan met behulp van brackets: [ ]. Dit werkt volgens de volgende structuur: x[m,n]. m = rows, n = kolom. Dit werkt niet uitsluitend op matrix maar op elk type object.

x <- c(1:20)
y <- matrix(data = x, nrow = 5, ncol = 4, byrow = TRUE)
y
##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12
## [4,]   13   14   15   16
## [5,]   17   18   19   20
# Roep uit x het component op uit de 2de kolom en 3de rij: x[m, n]
y[2, 3]       
## [1] 7
# extraheren van een hele rij: x[m, ]
y[2, ]       # de 2de rij
## [1] 5 6 7 8
# extraheren van een hele kolom. x[ ,n].
y[ ,3]       # de 3de kolom
## [1]  3  7 11 15 19
# Het is ook mogelijk om meer dan 1 rij of kolom per keer te extraheren.
y[ ,c(2,4)]  # de 2de en 4de kolom
##      [,1] [,2]
## [1,]    2    4
## [2,]    6    8
## [3,]   10   12
## [4,]   14   16
## [5,]   18   20

Matrix name index

kolommen en rijen hebben een label. Middels deze label]is de data uit een matrix op te roepen. Deze labels zijn te defineren met de colnames() en rownames() functies.

# Maak een matrix
x <- c(1:20)
y <- matrix(data = x, nrow = 5, ncol = 4, byrow = TRUE)
y
##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12
## [4,]   13   14   15   16
## [5,]   17   18   19   20
# hoeveel rijen heeft y?
nrow(y)
## [1] 5
# geef de rijen een naam. Gebruik een vector met EXACT dezelfde hoeveelheid als nrow(y)
rownames(y) <-  c('rij1', 'rij2', 'rij3', 'rij4', 'rij5') 

# roep de derde kolom op
y[ 'rij1' ,  ]
## [1] 1 2 3 4
# hoeveel kolommen heeft y?
ncol(y)
## [1] 4
# geef de rijen een naam. Gebruik een vector met EXACT dezelfde hoeveelheid als ncol(y)
colnames(y) <-  c('kolom1', 'kolom2', 'kolom3', 'kolom4') 

# roep de derde kolom op
y[ , 'kolom3']
## rij1 rij2 rij3 rij4 rij5 
##    3    7   11   15   19
# roep de eerste rij en derde kolom op
y[ 'rij1' , 'kolom3' ]
## [1] 3

Data.frame

Een dataframe is een tabel voor het opslaan van vectoren van gelijke lengte. In het kader van data analyse is dit de meest gebruikte vorm van data opslag. Neem bijvoorbeeld een tabel met op elke rij een patiënt en elke kolom een karakteristiek van de patiënt zoals leeftijd, geslacht etc. De reden hiervoor is dat hoewel je vaak niet voor alle patiënten alle informatie hebt is het wel noodzakelijk om er een “datapunt” voor te hebben: de (Missing Value). Een data.frame is te maken met de data.frame() functie.

# Maak verschillende type vectoren van dezelfde lengte
x <- c(3, 1, 4)
y <- c("aa", "bb", "cc")
z <- c(TRUE, FALSE, TRUE)

# Maak een data.frame
mijn.dataframe = data.frame(x, y, z)  
mijn.dataframe                 
##   x  y     z
## 1 3 aa  TRUE
## 2 1 bb FALSE
## 3 4 cc  TRUE

Data.frame numerieke index

Elementen uit een dataframe zijn op te roepen op dezelfde manier als uit een matrix: met de brackets: [rij,kolom].

# Maak een data.frame
mijn.dataframe <- data.frame(c(3, 1, 4), c("aa", "bb", "cc"), c(TRUE, FALSE, TRUE))  

# Roep een rij op
mijn.dataframe[1]
##   c.3..1..4.
## 1          3
## 2          1
## 3          4
# Roep een kolom op 
mijn.dataframe[ ,3]
## [1]  TRUE FALSE  TRUE
# Roep variabele uit een dataframe met een numerieke index
mijn.dataframe[1,3]
## [1] TRUE

Data.frame name index

Kolommen in een data.frame hebben een label. Middels deze label (naam van de variabele) is de data uit een data.frame op te roepen. Deze labels zijn te defineren met de names() functie. Om variabelen uit een data.frame op te roepen is het $ teken beschikbaar.

# Maak een data.frame
mijn.dataframe = data.frame(c(3, 1, 4), c("aa", "bb", "cc"), c(TRUE, FALSE, TRUE))  

# Geef de variabelen een naam met behulp van de numerieke index
names(mijn.dataframe)[1] <- "getal"
names(mijn.dataframe)[2] <- "tekst"
names(mijn.dataframe)[3] <- "logica"

# Roep nu de namen op van een data.frame
names(mijn.dataframe)
## [1] "getal"  "tekst"  "logica"
# Roep de variabele 'getal' op met het name index $ teken
mijn.dataframe$getal
## [1] 3 1 4

List

Een list is een generieke vector bestaande uit verschillende componenten die los van elkaar staan. Een list kan vectoren met verschillende lengtes en datatypes bevatten (anders dan een dataframe waarbij alle vectoren van dezelfde lengte moeten zijn). Een voorbeeld van een list:

x <- c(2:5)
y <- c(T,F,T,F)
z <- matrix(c(1:4),nrow=2,ncol=2)
mijnlijst <- list(x,y,z)
mijnlijst
## [[1]]
## [1] 2 3 4 5
## 
## [[2]]
## [1]  TRUE FALSE  TRUE FALSE
## 
## [[3]]
##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4

List index

Om een onderdeel (list-slice) uit een list te halen worden de brackets [ ] gebruikt. Om direct op een list slice te richten worden de double brackets gebruikt: [[ ]].

# een verkorte versie van de list uit bovenstaande versie
mijnlijst <- list(c(2:5),c(T,F,T,F),matrix(c(1:4),nrow=2,ncol=2))

# Enkele brackets
mijnlijst[2] 
## [[1]]
## [1]  TRUE FALSE  TRUE FALSE
# Dubbele brackets 
mijnlijst[[2]] 
## [1]  TRUE FALSE  TRUE FALSE
# Gebruik de dubbele brackets + enkele brackets om de 2ste variabele uit de 1de vector uit "mijnlijst" te halen
mijnlijst[[1]][2]
## [1] 3

Lees meer op R-Wiki


Factors

Factor is een data class bedoeld voor categoriale variabelen. Een factor class is te creëren uit een vector van het numeric, character of integer class. R kan zelf de levels genereren en dit is ook zelf te specificeren. Hiervoor wordt de functie factor() gebruikt.

# Van numeriek naar factor: AUTOMATISCHE LEVELS
data <- c(1,2,2,3,1,2,3,3,1,2,3,3,1)      # genereer numerieke data
factor_data <- factor(data)               # factoriseer data
factor_data
##  [1] 1 2 2 3 1 2 3 3 1 2 3 3 1
## Levels: 1 2 3
# van numeriek naar factor: ZELF LEVELS DEFINEREN
sex_binair <- c(2, 1, 1, 2, 0, 1, 1)   
namen <- c(man = 1, vrouw = 2)
sex_factor <- factor(sex_binair, levels = namen, labels = names(namen))
sex_factor
## [1] vrouw man   man   vrouw <NA>  man   man  
## Levels: man vrouw
# De levels zijn op te roepen met de levels() functie
levels(sex_factor)
## [1] "man"   "vrouw"

Let op: in bovenstaand voorbeeld (sex_factor) komt ook het element “0 voor. Deze is niet expliciet vernoemd in de levels van de factor() functie. Deze waarde wordt automatisch gelabeled als NA (missing value). Elke waarde die niet correspondeert met een level wordt krijgt als label NA.

Voor meer informatie over factors zie UCLA Statistics


Datum en tijd

Om met datum en tijden te werken in R is het vaak nodig om te specificeren hoe de dag en tijd zijn opgeslagen voordat R ermee kan werken.

Character to Dates

De belangrijkste functies worden besproken: as.Date() , format(), as.POSIXlt() en as.POSIXct().

# Welke dag is het?
Sys.Date()
## [1] "2015-04-16"
# alternatief
date()
## [1] "Thu Apr 16 00:13:37 2015"
# Gebruik as.Date() om text om te zetten in 'datum/tijden'
# De standaard conversie format is: yyyy-mm-dd.
datum <- as.Date(c("2007-06-22", "2004-02-13"))
print(datum)
## [1] "2007-06-22" "2004-02-13"
class(datum)
## [1] "Date"
# Gebruik de symbolen om de format te wijzigen
# Converteer characters naar datum/tijd in de format 'mm/dd/yyyy'
strDates <- c("01/05/1965", "08/16/1975")
dates <- as.Date(strDates, "%m/%d/%Y")
dates
## [1] "1965-01-05" "1975-08-16"

Format

Gebruik de format() functie om te specificeren hoe de datum/tijd is opgeslagen in de tekst

# welke dag is het?
Sys.Date()
## [1] "2015-04-16"
# Welke dag en tijd is het nu?
Sys.time()
## [1] "2015-04-16 00:13:37 CEST"
# Defineer een format
format(Sys.time(), "%a %b %d %X %Y %Z")
## [1] "do apr 16 0:13:37 2015 CEST"
## extraheer uit een sys.date de dag van vandaag
vandaag <- Sys.Date()
format(vandaag, format="%B %d %Y")
## [1] "april 16 2015"
Symbool Betekenis Voorbeeld
%d dag (numeric) 01-31
%A weekdag monday
%a weekdag (kort) mon
%m maand (numeric) 00-12
%B maand January
%b maand (kort) Jan
%Y jaar 2015
%y jaar (kort) 15

Lijst van alle afkortingen te gebruiken bij format(): R-Manual

Gebruik help(as.Date) en help(strftime) voor meer informatie over het converteren van characters naar datum/tijden. Gebruik help(ISOdatetime) voor meer informatie over de formatting.

POSIXct en POSIXlt

Er zijn verschillende manieren waarop R datum en tijden bewaart. POSIXct bewaart de tijden in seconden sinds het begin van de telling: standaard is dit 1970-01-01. POSIXlt bewaart de datum/tijd als een lijst van dagen, maanden, jaren, uren, minuten en seconden.

SPSS dates

SPSS bewaart datum en tijden volgens een POSIXct format. Echter begint de telling bij SPSS vanaf het begin van het Gregoriaanse kalender: 1582-10-14. Om Datum/tijden in de vorm van POSIXct te transformeren naar datum/tijden waar R mee kan werken maak gebruik van onderstaand voorbeeld:

## SPSS dates
spssDates <- c(10485849600, 10477641600, 10561104000, 10562745600)
as.Date(as.POSIXct(spssDates, origin = "1582-10-14", tz = "GMT"))
## [1] "1915-01-26" "1914-10-23" "1917-06-15" "1917-07-04"

Creative Commons-Licentie Dit werk valt onder een Creative Commons Naamsvermelding - Gelijk Delen 3.0 Internationaal-licentie .