1.1 Kasutajaliides

Windowsis on R-il äärmiselt minimalistlik kasutajaliides. Programmi käivitades on näha ainult konsooliaken. Rea ees olev märk > näitab, et R ootab uut käsku. Seda saab sümboli > järele kirjutada, sealjuures võib seda teha mitmel real. Kui R-i arvates on käsu sisestamine pooleli, on konsoolirea alguses sümbol +. Kui käsk on sisestatud, siis enter-klahvi vajutamise järel käsk täidetakse ja tulemus trükitakse konsooliaknasse. Sageli on siis rea alguses kantsulgudes mingi arv, mis näitab, mitmes tulemuse element on rea alguses – nimelt võib tulemus mõnikord koosneda mitmest elemendist.

> 4 * 6

[1] 24

> 4 * 
+ 6

[1] 24

> 4 * (1:40)

 [1]   4   8  12  16  20  24  28  32  36  40  44  48  52  56  60  64  68
[18]  72  76  80  84  88  92  96 100 104 108 112 116 120 124 128 132 136
[35] 140 144 148 152 156 160

Kui konsooliaknas olles vajutada üles- või allanooleklahvi, saab sirvida eelnevalt täidetud käske.

Konsooli käskude sisestamise asemel on neid mõistlik kirjutada skriptifaili, et hiljem (nt järgmisel päeval) saaks tehtud töö (näiteks mingi analüüsi) kiiresti uuesti üle teha. Skriptifaili tekitamiseks tuleks valida menüüst File valik New script. Avatakse skriptiaken, kuhu saab käske kirjutada. Kui skriptiaknas olles vajutada klahve Ctrl+R, siis vastaval real olev käsk saadetakse R-ile täitmiseks. Kui käsk on kirjutatud mitmel real või on soov mitut käsku järjest jooksutada, võib vastavad read skriptiaknas hiirega ära märkida ning seejärel Ctrl+R vajutada. Valides menüüst File valiku Save, salvestatakse .R lõpuga skriptifail kasutaja poolt määratud asukohta.

Kommentaare saab R-i koodis lisada ainult rea lõppu, kasutades trellide-sümbolit:

log(5.9)  # võtame naturaallogaritmi arvust 5,9
# terve see rida on kommentaar, sest rea alguses on # ehk trellide sümbol

Kümnendmurru eraldamiseks kasutatakse R-is punkti, mitte koma.

Kahjuks on R-i kasutajaliides mõnevõrra ebamugav. Näiteks konsooliaknas ei saa hiirega kursori asukohta muuta. Samuti on kogu tekst sama värvi (koodi värvimine puudub). Üks alternatiivne kasutajaliides R-i kasutamiseks on RStudio², kus neid puuduseid pole ning millega on natuke hõlpsam koodi kirjutada.

1.2 Lihtsam aritmeetika

R-is on võimalik teha kõiki lihtsamaid aritmeetilisi tehteid, sealjuures järgitakse matemaatikas kasutatavat tehete järjekorda (sulgusid lisades on võimalik seda muuta):

• 1 + (2 - 3) * 4 / 5
• 2^3 - 2**3 – astendamiseks saab kasutada sümboleid ^ ja **
• 5 %% 3 – modulo (jääk jagamisel)
• log(exp(1)) * cos(-pi) * sqrt(9) + factorial(4) - choose(4, 2) * min(4, 5, 2)
  on sama, mis \(\ln{(e^1)} \cdot \cos{(-\pi)} \cdot \sqrt{9} + 4! - \binom{4}{2} \cdot \min(4,5,2)\)
• 1/0 annab tulemuseks Inf (infinity)
• 0/0 annab tulemuseks NaN (not a number)
• sum(1, 5, 6) – summeerib kõik arvud
• prod(1, 5, 6) – korrutab kõik arvud

1.3 Käsud ja abi saamine

Kõige lihtsam on abi saada interneti otsimootorite kaudu.

Ülalolevad aritmeetikaavaldised sqrt(9), choose(4, 2) jne on tegelikult käsud ehk funktsioonid, mis oskavad teatud asju teha (praeguses näites teatud arvutusi teha). Kõigil käskudel on sarnane süntaks:

käsk(argumendid)

Üldiselt on käsu argumentidel tegelikult ka nimed, näiteks käsk choose tahab täpselt kahte argumenti: n ja k. Mõnikord on kasulik argumentide nimed välja kirjutada, et hiljem koodi üle lugedes oleks aru saada, mida miski tähendab:

choose(n = 4, k = 2)

Kui kasutada argumentide nimesid, siis ei ole tähtis, millises järjekorras argumendid käsule ette anda. Ent kui argumentide nimesid ei kasuta, tuleb olla ettevaatlik:

choose(k = 2, n = 4)

## [1] 6

choose(2, 4)

## [1] 0

Kui mingi konkreetse käsu kohta soovitakse abi saada (näiteks kontrollida, mis on käsu argumentide nimed ja millises järjekorras need tuleks ette anda), võib konsooli trükkida ?käsu_nimi või ka ??otsitav_tekst:

?choose
??"logarithm"

Tasub tähele panna, et R on (nagu suurem osa programmeerimiskeeli) tõstutundlik – see tähendab, et suured ja väikesed tähed on erinevad:

Log(5)

## Error in eval(expr, envir, enclos): could not find function "Log"

1.4 Objektid ja töökeskkond (environment)

Sageli on mugav, kui töös kasutatavatele asjadele nimi anda – siis saame neid asju nimepidi kutsuda. Näiteks kui nimetada kaal <- 70 ja pikkus <- 185, siis saaks kehamassiindeksit arvutada nii:

kaal / (pikkus / 100)**2

## [1] 20.45289

Tekitasime töökeskkonda kaks objekti, mille nimed on kaal ja pikkus. Täpsemini: tekitasime objektid kaal ja pikkus, millele omistasime väärtused 70 ja 185. Sümboliühendit <- nimetatakse omistamisoperaatoriks. Üldjuhul töötab omistamisoperaatorina ka võrdusmärk =, ent on mõned erandjuhtumid, kus need erinevalt töötavad; lisaks on võrdusmärk kasutusel käskude argumentidele väärtuse andmisel.

Mõistlik on jätta omistamisoperaatori (ja ka muude, nt võrdlusoperaatorite) ümber tühikud. Näiteks x<-3 teostab omistamise, kuigi võib-olla kasutaja tahtis objekti x võrrelda arvuga -3. Võrdlemise jaoks peaks kirjutama x < -3, omistamise jaoks peaks kirjutama x <- 3.

Kui nüüd muuta kaal väärtust: kaal <- 90 , siis konsoolis ülesnoolega üle-eelmise käsu (KMI arvutamise) üles otsides saab seda lihtsasti uuesti jooksutada.

Töökeskkonnas olevatest objektidest saab ülevaate käsuga ls(). Lisaks skriptifailile on võimalik ka töökeskkonda salvestada ning hiljem see uuesti sisse laadida. Selleks saab kasutada käske save(.) ja load(.); Windowsis saab ka menüü abil: peab konsooliakna aktiivseks tegema ja valima menüüst File vastavalt Save workspace või Load workspace.

Töökeskkonnas olevaid objekte saab kustutada käsuga rm(.):

rm(kaal, pikkus)

Töökeskkonda on võimalik salvestada RData failiks käsuga save(.) või valides menüüst File -> Save workspace.... Siis salvestatakse kõik antud töökeskkonnas olnud objektid sellesse faili. Hiljem saab kõik need objektid jälle RData failist töökeskkonda laadida käsuga load(.). RData formaati üldiselt teised statistikaprogrammid lugeda ei oska.

2.1 Andmete sisselugemine ja faili kirjutamine

Tavaliselt koosnevad andmestikud ridadest ja veergudest (tulpadest), kus iga rida vastab mingile mõõtmisobjektile ja iga veerg vastab mingile mõõdetud omadusele (tunnusele). Erinevad statistikaprogrammid kasutavad andmestike säilitamiseks eri failiformaate. Et andmestikke ühest programmist teise saada, on mõistlik andmetabel salvestada tekstiformaadis failiks, näiteks .txt või .csv tüüpi failiks.

Kõige olulisem käsk tekstikujul andmestike sisselugemiseks on read.table(). Sellel on mitmeid argumente, mille abil saab täpsustada erinevaid asjaolusid, mis antud andmestikku puutuvad:

Faili asukoht võib olla kõvakettal või võrgus. Kui käsu setwd abil on määratud, milline on käimasoleva töösessiooni töökataloog, ja andmefail on selles kataloogis, siis piisab ainult faili nime andmisest (täispikka asukohta ei pea andma). Windowsis on kombeks kaustastruktuuri tähistamiseks kasutada kurakaldkriipsu (tagurpidi kaldkriipsu) \, aga R-is on sellisel kaldkriipsul eriline tähendus – sellega märgitakse, et järgneb erisümbol (nt \t on tabulaatori sümbol). Seepärast tuleb Windowsis kasutada kahekordseid kurakaldkriipse, näiteks:

setwd("C:\\Users\\mina\\Rkursus\\")

Teine võimalus on kasutada tavalist kaldkriipsu, nagu MacOS-is ja Linuxites:

setwd("C:/Users/mina/Rkursus/")

Andmete sisselugemisel tuleks anda andmetabelile nimi (salvestada see mingi objektina), vastasel juhul andmestik trükitakse lihtsalt ekraanile ja sellega enam midagi muud teha ei saa:

andmed <- read.table("http://kodu.ut.ee/~maitraag/rtr/mass.txt", sep = "\t")

Töökeskkonnas olevaid andmetabeleid saab tekstiformaadis faili (mida teised programmid sisse lugeda oskavad) kirjutada käsuga write.table.

Mõnd enamlevinud statistikatarkvara-spetsiifilist formaati (nt Stata .dta, SPSS-i, .sav) on võimalik lisapaketti foreign kasutades samuti sisse lugeda. Lisapakettidest tuleb juttu hiljem.

2.2 Andmestiku kirjeldamine.

Käsuga read.table sisse loetud andmestik on erilist tüüpi, data.frame tüüpi objekt. Andmestikust saab kiire ülevaate järgmiste käskudega:

Käsu summary puhul on näha, et mõne tunnuse puhul arvutatakse keskmine, miinimum, maksimum jne, aga teise tunnuse puhul esitatakse sagedused. Kuidas R teab, mida teha? Väga lihtsalt: tunnuse tüübi järgi. Kui käsuga str vaadata, mis on tunnuste tüübid selles andmestikus, on näha kahte tüüpi tunnuseid: int ja Factor. On näha, et summary käsk arvutab int-tüüpi tunnustele keskmisi jne, Factor-tüüpi tunnustele aga sagedusi.

2.3 Veergude ja ridade eraldamine andmestikust: indeksi ja nime järgi

Kui tahame andmestikust ainult üht veergu uurida, siis kõige mugavam on kasutada dollari-sümbolit:

vanused <- andmed$AGEP
median(andmed$AGEP)
median(vanused)

Üldiselt on data.frame kahemõõtmeline tabel, mis tähendab, et iga elemendi asukoht selles tabelis on ära määratud rea ja veeru numbriga. Rea- ja veerunumbrite abil andmestikust infot eraldades tuleb kasutada kantsulgusid:

andmed[3, 2]  # kolmas rida, teine veerg
andmed[ , 2]  # kogu teine veerg
andmed[3,  ]  # kogu kolmas rida

Korraga on võimalik eraldada ka mitut rida või veergu, kasutades selleks vahest kõige olulisemat käsku c(.):

andmed[, c(2, 4)]  # teine JA kolmas veerg, trükitakse ekraanile
teinekolmas <- andmed[, c(2, 4)]  # teine ja kolmas veerg salvestatakse uude andmestikku / uue objektina
huvipakkuvad_veerud <- c(2, 4)  # tekitame objekti, milles on kirjas huvipakkuvate veergude numbrid
andmed[, huvipakkuvad_veerud]  # kasutame seda objekti andmestikust veergude eraldamiseks
andmed[c(5, 9), ]  # viies JA üheksas rida

Tihti on veeruindeksite asemel mugavam kasutada veergude nimesid, mida samuti kantsulgudes kasutada (peavad olema jutumärkides):

andmed[, c("AGEP", "WAGP")]  # eraldame veerud "AGEP" ja "WAGP"

Mõnikord harva on ka ridadel nimed, siis saab neid sama moodi kasutada ridade eraldamisel.

2.4 Lihtsam kirjeldav statistika

Allpool on mõned käsud, mille abil huvipakkuvat tunnust (veergu) kirjeldada.

• min(tunnus), max(tunnus), median(tunnus), mean(tunnus), sd(tunnus) – arvulise tunnuse karakteristikud
• quantile(tunnus, kvantiil) – saab leida kvantiile ehk protsentiile arvulisele tunnusele
• length(tunnus) – mitu elementi on antud veerus
• table(tunnus) – saab koostada sagedustabelit (kasulik Factor-tüüpi tunnuse kirjeldamisel)
  table(tunnus1, tunnus2) – koostab kahemõõtmelise sagedustabeli table(tunnus1, tunnus2, tunnus3) – kolmemõõtmeline sagedustabel; inimesel ebamugav lugeda, arvutiga töödelda aga mugav
• t(tabel) – vahetab tabeli read ja veerud (transponeerib)
• ftable(tunnus1 + tunnus2 ~ tunnus3 + tunnus4, data = andmed) – teeb mitmemõõtmelise sagedustabeli, mis on inimesele lihtsasti loetav

Kui on soov korraga mitme arvulise tunnuse keskmisi arvutada, sobib selleks käsk colMeans(tunnus), sarnane käsk on rowMeans(.). Ridade või veergude summasid saab leida käskudega rowSums(.) ja colSums(.). Seda saab näiteks ära kasutada sagedustabeli põhjal protsentide arvutamiseks:

sagedustabel <- table(andmed$SEX, andmed$LANX)
sagedustabel / rowSums(sagedustabel)  #proovi, mis juhtub, kui kasutada /colSums(.)

##         
##          No, speaks only English Yes, speaks another language
##   Female               0.8031949                    0.1968051
##   Male                 0.8147019                    0.1852981

Sagedustabeli põhjal protsentide arvutamiseks (jaotustabeli arvutamiseks) on mugavam kasutada käsku `prop.table(.):

prop.table(sagedustabel)  # ühisjaotus
prop.table(sagedustabel, margin = 1)  # iga rida kokku 1 (ehk 100%)
prop.table(sagedustabel, margin = 2)  # iga veerg kokku 1 (ehk 100%)

2.5 Puuduvad väärtused

Käsu summary(andmed) väljatrükis oli näha (tunnuse MARHT – mitu korda abielus olnud – järgi), et 3026 inimest oli abielus olnud ühe korra, 575 inimest kaks korda ning 63 inimest kolm korda või rohkem. Lisaks oli 2760 inimese juurde märgitud NA. Nimelt on puuduv väärtus kodeeritud sümboliga NA. Üldiselt tasub puuduvate väärtuste olemasolul olla ettevaatlik. Sageli saab R-i käskudele argumenti na.rm kasutades öelda, mida puuduvate väärtusega ette võtta. Kui on soov teada saada, mitu väärtust on puudu, saab kasutada käskude kombinatsiooni sum(is.na(tunnus)):

mean(andmed$WAGP)   # mõnel inimesel pole palganumbrit öeldud -- ei oska keskmist arvutada

## [1] NA

mean(andmed$WAGP, na.rm = TRUE)  # ignoreerime keskmise arvutamisel puuduvaid väärtuseid

## [1] 33162.34

table(andmed$LANX)

## 
##      No, speaks only English Yes, speaks another language 
##                         4919                         1163

table(andmed$LANX, useNA = "always")  # table käsuga on teistmoodi...

## 
##      No, speaks only English Yes, speaks another language 
##                         4919                         1163 
##                         <NA> 
##                          342

sum(is.na(andmed$LANX))

## [1] 342

2.6 Vektorid. Tehted vektoritega

Eelpool oleme mitme veeru (või rea) korraga eraldamiseks kasutanud käsku c(.). Tegemist on käsuga, mis sellele antud argumendid kombineerib (combine) kokku üheks vektoriks (järjendiks). Kui kombineeritakse erinevat tüüpi väärtuseid (näiteks teksti ja arve), siis muudetakse kõik väärtused selliseks, mis võimaldab võimalikult palju infot säilitada – kõik vektori elemendid peavad olema sama tüüpi.

c(987, -Inf, "siin on jutumärkides tekst") # pane tähele jutumärke allolevas väljatrükis

## [1] "987"                        "-Inf"                      
## [3] "siin on jutumärkides tekst"

Arvudest koosneva vektori tekitamiseks on ka muid mooduseid:

1:5  # täisarvud 1-st 5-ni

## [1] 1 2 3 4 5

2:-6 # täisarvud 2-st -6-ni

## [1]  2  1  0 -1 -2 -3 -4 -5 -6

seq(from=0, to=11, by=2) #arvud 0, 0+2, 0+2+2, ..., kuni jõutakse väärtuseni 11

## [1]  0  2  4  6  8 10

seq(1, 0, -0.1) # saab ka komaga arvudest järjendeid teha

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

seq(0, 1, length.out=4)  

## [1] 0.0000000 0.3333333 0.6666667 1.0000000

rep(x=3, times=2)  # arvu 3 korratakse 2 korda

## [1] 3 3

Käsku rep saab kasutada ka sõnede kordamisel: rep("as_9", 4).

R-i puhul on huvitav see, et sageli tehakse mitmesuguseid tehteid elemendiviisiliselt. Mõnikord tasub olla ettevaatlik: kui asjaosalised vektorid on erineva pikkusega, siis lühemat pikendatakse automaatselt rep käsu laadselt.

1:3 * 4     # iga element korrutatakse 4-ga läbi 

## [1]  4  8 12

1:3 + 9:7   # kahe vektori elemendid liidetakse paarikaupa

## [1] 10 10 10

1:6 * c(1, 2)  # iga teine element korrutatakse 2-ga, ei hoiatata

## [1]  1  4  3  8  5 12

1:7 * c(1, 2)  # antakse küll hoiatus, aga 7. element korrutatakse 1-ga

## Warning in 1:7 * c(1, 2): longer object length is not a multiple of
## shorter object length

## [1]  1  4  3  8  5 12  7

2.7 Tõeväärtused ja tõeväärtusvektorid

Kui käsuga sum kasutada argumenti na.rm, siis argumendi väärtus võib olla TRUE või FALSE. Tegemist on tõeväärtustega. Kuna tõeväärtustega saab teha loogilisi tehteid (ehk neid kombineerida), siis on neist kasu ka mujal kui na.rm argumendi kasutamisel.

Loogilisi tehteid on kolm: korrutamine (&), liitmine (|) ja eitus (!).

Sageli on tulemuseks tõeväärtus siis, kui võrdleme kahte objekti/väärtust omavahel.

Nagu eelpool mainitud, siis R-is tehakse tehteid vektoritega elementhaaval. Seepärast ka siis, kui võtame mingi arvulise vektori (näiteks palkade veeru) ja võrdleme seda mingi arvuga, siis võrreldakse igat elementi eraldi ja tulemuseks on tõeväärtustest koosnev vektor, milles on sama palju elemente kui oli elemendiviisilisi võrdluseid. Sama kehtib ka juhul, kui võrreldakse muud tüüpi väärtuseid (näiteks tekstilisi väärtuseid).

vaikepalk <-  andmed$WAGP < 1000
table(vaikepalk)

## vaikepalk
## FALSE  TRUE 
##  3410  1903

Kui soovime mingit väärtust võrrelda NA-ga, et teada saada, kas tegemist on puuduva väärtusega või mitte, siis topeltvõrdusmärgid ei tööta, vaid tuleb kasutada käsku is.na(.).

Mõnikord on soov kontrollida, kas mingi väärtus leidub etteantud hulgas. Sobilik on siis kasutada operaatorit %in% :

1:4 %in% c(2, 5)

## [1] FALSE  TRUE FALSE FALSE

Tõeväärtuste puhul on huvitav see, et kui nendega tavalisi arve korrutada või liita või muid aritmeetilisi tehteid teha, siis konverteeritakse tõeväärtused arvudeks: TRUE muutub arvuks 1 ja FALSE muutub arvuks 0.

sum(vaikepalk, na.rm = T)

## [1] 1903

sum(is.na(vaikepalk))  # mitmel inimesel on palk puudu

## [1] 1111

sum(vaikepalk == NA)   # see ei tööta nii, nagu sooviks...

## [1] NA

Konverteerimine toimib automaatselt. Kui on endal soov tõeväärtuseid arvuliseks muuta, saab kasutada käsku as.numeric(.). Saab ka vastupidi: kui on soov arvusid tõeväärtusteks muuta, saab seda teha käsuga as.logical(.). Proovi!

2.8 Ridade eraldamine

Tõeväärtusvektoreid on väga mugav kasutada nn filtritena. Nimelt on data.frame puhul võimalik ridu (ja ka veerge) eraldada mitte ainult reaindeksi või -nime järgi, vaid ka tõeväärtusvektori abil. Vastav tõeväärtusvektor peab olema sama pikk kui on andmestikus ridu, iga väärtus selles vektoris näitab, kas vastavat rida kasutada või mitte. Tõeväärtusvektorite kombineerimisel saab andmestikust väga spetsiifilisi alamhulki eraldada.

mehed <- andmed[andmed$SEX == "Male", ]  # eraldame kõik read, kus SEX == "Male" ning   
#salvestame selle uueks objektiks
filter_kod <- andmed$CIT == "Not a citizen of the U.S."
filter_vanus <- andmed$AGEP >= 80
alamandmestik <- andmed[filter_kod & filter_vanus, ]   # Ära unusta: [read, veerud]

2.9 Väärtuste tüübid. Faktortunnus

Nägime eespool str(.) käsku kasutades, et andmestiku veerud on erinevad tüüpi. Massachusettsi andmestikus oli erinevaid tüüpe kaks: int ja Factor. R-is on veel teisigi väärtuste tüüpe, mõned sagedamini esinevad on:

• int / integer – täisarvud (ka negatiivsed)
• numeric – reaalarvud
• char / character – sõned (tähemärgid ja muud tekstilised sümbolid)
• logical – tõeväärtused (ainult kaks väärtust: TRUE või FALSE)
• Factor – faktortunnus

Üht tüüpi väärtust saab teisendada teist tüüpi väärtuseks vastava as.X käsuga (as.integer, as.numeric, as.character jne). Kontrollimaks mingi väärtuse tüüpi saab kasutada vastavat käsku is.X (is.integer, is.character jne).

Faktortunnus pole tegelikult nn elementaartüüp (nagu näiteks integer), vaid keerulisem konstruktsioon. Nimelt faktortunnus on sildistatud täisarvude tunnus. Kui andmestik R-i sisse loetakse, siis vaikimisi pannakse tähelisi väärtuseid sisaldavate tunnuste tüübiks factor (seda võib ka read.table(.) argumendiga stringsAsFactors keelata) ning iga erinev väärtus kodeeritakse mingi täisarvuga, aga lisaks tehakse kodeerimistabel, kus on kirjas iga täisarvu (kodeeringu) tekstiline väärtus (ehk silt).

Et teada saada, mitu erinevat väärtust antud faktortunnusel võib üldse olla, kasutatakse käsku levels(.). Sealjuures ei pruugi kõigi tasemega väärtuseid andmestikus üldse olla:

levels(mehed$SEX) # meeste andmestikust võtame soo veeru

## [1] "Female" "Male"

Faktortunnuse tekitamiseks saab kasutada käsku factor(.). Vaikimisi pannakse faktortunnuse tekitamisel faktori tasemed tähestiku järjekorda. Seda saab aga muuta käsu factor(.) argumenti levels kasutades:

table(andmed$MARHT) # Mitu korda abielus olnud?
andmed$MARHT <- factor(andmed$MARHT, levels = c("One time", "Two times", "Three or more times"))
table(andmed$MARHT)

Mõnikord on arvulised tunnused faktorkujul sellepärast, et ühes lahtris oli mingi tekst. Kui nüüd proovida as.numeric(.) käsuga see tunnus arvuliseks teisendada, tekib segadus: Factor-tüüpi tunnus on juba täisarvude tunnus (kuigi neil on sildid juures) ning seetõttu antakse tulemuseks need täisarvud ehk kodeeringud. Segadust ei teki, kui faktortunnus kõigepealt sõneks teisendada (kodeeringud kaotatakse, jäävad ainult sildid) ning alles seejärel arvudeks.

(x <- factor(c("1", "8", "ei vastanud", "12"))) # välimised sulud tingivad väljatrüki

## [1] 1           8           ei vastanud 12         
## Levels: 1 12 8 ei vastanud

(as.numeric(x))

## [1] 1 3 4 2

(as.numeric(as.character(x)))

## Warning: NAs introduced by coercion

## [1]  1  8 NA 12

Mõnikord soovime arvulist tunnust muuta nn ordinaaltunnuseks (st selliseks, kus on mõned üksikud kategooriad, mis on omavahel järjestatud). Näiteks palkade statistika esitamisel on soov teada infot palgavahemike kaupa. Arvulist tunnust aitab lõikudeks tükeldada käsk cut(.). Selle käsu tulemusel tekib faktortunnus, mille silte saab cut(.) käsu argumendiga labels ette anda:

palgad = cut(x=andmed$WAGP, breaks=c(0, 999, 4999, Inf), include.lowest=T,
             labels=c("0--999", "1000--4999", ">= 5000"))

3.0.1 Ülesanded

1. Paigalda oma arvutisse pakett ggplot2 (koos nende pakettidega, mis on ggplot2 jaoks vajalikud).

4.1 Graafika R-is. ggplot2 ja graafikute grammatika

R-i üks tugevaid külgi on tema jooniste tegemise võimekus. Paar kõige rohkem kasutatavat joonistamise käsku:

par(mfrow = c(1, 2), cex = 0.6)  # see rida võimaldab kaks joonist kõrvuti panna
hist(andmed$AGE, xlab="Vanus", ylab="Isikuid", main="")
plot(andmed$WKHP, andmed$WAGP, xlab="Töötunde", ylab="Aastapalk", col=as.numeric(andmed$SEX)+1)
legend("topleft", pch=19, col=2:3, legend=levels(andmed$SEX))

Kuigi R-i baasgraafika on peensusteni konfigureeritav ja sellega saab teha ülikeerulisi jooniseid, peab tüüpilisemate andmeid kirjeldavate jooniste saamiseks tegema palju lisatööd ja -arvutusi, nagu ülalolevastki näha. Näiteks barplot(.) käsk soovib argumendiks saada sagedustabelit, mis tuleks siis eelnevalt table(.) käsu abil arvutada.

R-i kasutajate hulgas on viimastel aastatel muutunud populaarseks pakett ggplot2, mis võimaldab lihtsamini joonistada andmestikke kirjeldavaid jooniseid, sealjuures on tulemused visuaalselt üsna apetiitsed. Nimelt on ggplot2 arendamisel pandud tähele statistiku E. Tufte soovitusi värvide valikul ning eriti L. Wilkinsoni struktureeritud käsitlust andmejoonistest, nn graafikute grammatikat (grammar of graphics).

Üldised soovitused (Tufte):

• vähema tindiga edastada rohkem infot;
• ei tohiks rõhutada mõnda elementi, kui see pole teistest oluline (nt kõik värvid võiksid olla sama intensiivsusega);
• eelistada silmaga lihtsamini hinnatavaid kujundeid (nt tulba kõrgus tulpdiagrammil on lihtsamini hinnatav kui nurgakraad või sektori pindala ringdiagrammil);
• eemaldada infot mitte sisaldavad komponendid (nt liba-3D).

Graafikute grammatika (Wilkinson) on kontseptsioon, mille kohaselt graafiku ehitamisel ei tuleks lähtuda mitte graafiku tüübist, vaid andmetest. Iga joonis koosneb järgnevatest osadest:

• andmed (inimeste palk ja sugu);
• skaalad (kas esitada palk värviskaalal või x-teljel? kas palga esitamiseks sobib nt log-skaala?);
• statistikud (kas palga puhul kujutada keskmist või summat);
• geomeetrilised kujundid (kas keskmine peaks olema märgitud tulba kõrgusega või hoopis punktikesega);
• koordinaadid (äkki sobib polaarkoordinaadistikus?);
• tahud (joonis jagatud erinevateks alamjoonisteks);
• üldkujundus (font jms).

Paketis ggplot2 on kaks graafikute tekitamise käsku: ggplot(.) (keerukam) ja qplot(.) (quick plot, lihtsam). Meie kasutame praegu ainult qplot(.) käsku. Selle paketi käskude jaoks on kõige põhjalikum dokumentatsioon internetis: http://docs.ggplot2.org/current/ . Kuna tegemist on endiselt väga noore paketiga, siis uuemate versioonide käskude süntaks või toimimine võib olla erinev vanemate versioonide omast (viimati oli oluline muutus opts(.) käsu asendamine theme(.) käsuga). Ka dokumentatsioon pole veel täielik (aga oluliselt parem, kui paar aastat tagasi).

4.2 ggplot2: hajuvusdiagramm; skaalad

Failis http://kodu.ut.ee/~maitraag/rtr/maakonnad.txt on info USA viie osariigi mõnede maakondade (regioonide) kohta (425 maakonda). Uurime kõrgharidusega inimeste osakaalu ja keskmise sissetuleku vahelist seost. Mõistlik on seda kujutada hajuvusdiagrammina, kus iga punkt on maakond ning ühel teljel on kõrgharidusega inimeste osakaalu märkiv tunnus bachelor ja teisel teljel keskmine sissetuleku tunnus per_capita_inc:

mk <- read.table("http://kodu.ut.ee/~maitraag/rtr/maakonnad.txt", sep = " ")
qplot(x = bachelor, y = per_capita_inc, data = mk)

Lisaks koordinaatidele saab üks punkt veel edasi anda infot näiteks värvi, kuju ja suurusega:

qplot(x = bachelor, y = per_capita_inc, data = mk, colour = Poverty_factor, 
      size = pop_estimate, shape = State)

Igat tüüpi tunnuseid ei saa suvaliste jooniseühikutega seostada, näiteks pideva tunnusega ei saa siduda punkti kuju (nii palju erineva kujuga punkte pole lihtsalt olemas). Samas aga saab värviga kujutada nii faktortunnust (nt osariik) kui ka arvulist tunnust (nt kõrgus merepinnast). Täpsemini on hajuvusdiagrammi ühel punktil järgmised omadused, millega saab infot edasi anda:

• x – (kohustuslik) asukoht x-teljel [numeric, character, logical, Factor]
• y – (kohustuslik) asukoht y-teljel [numeric, character, logical, Factor]
• alpha – läbipaistvus, väiksem väärtus tähendab suuremat läbipaistvust [numeric, character, logical, Factor]
• colour – värvus [numeric, character, logical, Factor]
• fill – sisemuse värvus (ainult mõne shape väärtuse korral) [numeric, character, logical, Factor]
• shape – punkti kuju (kuni 25 erinevat + ise määratavad sümbolid) [logical, character, Factor]
• size – punkti suurus [numeric, character, logical, Factor]

4.3 ggplot2: tulpdiagramm; elementide asukoht

Graafiku teljed võivad olla seotud ka diskreetse tunnusega (nt Factor), näiteks võiksime maakondi kujutades siduda x-teljega osariigi:

qplot(x = State, data = mk)

Tekkis tulpdiagramm, kus iga tulp näitab maakondade arvu vastavas osariigis. Ent maakonnad ühe tulba sees võivad olla erinevad, näiteks vaesustaseme (Birth_factor) poolest. Selleks võib iga tulba vastavate maakondade arvu järgi ära värvida. Kuna iga joonise element koosneb piirjoonest ning sisemisest osast, tuleb vastava osa värvi muutmiseks kasutada kas argumenti colour või fill:

qplot(x = State, data = mk, fill = Poverty_factor, colour = State)  # praegu on colour 
# argument ebavajalik,  sama info on juba x-teljel olemas

Samas võib iga tulba ka tükkideks jaotada ja panna üksteise kõrvale, andes argumendile position väärtuse position="dodge". (NB! Jutumärgid)

qplot(x = State, data = mk, fill = Poverty_factor, position = "dodge")

Kuna suuremates osariikides on rohkem maakondi, oleks võib-olla informatiivsem näha suhtelisi sagedusi. See tähendab, et iga osariigi tulp võiks olla sama kõrge (100%):

qplot(x = State, data = mk, fill = Poverty_factor, position = "fill")

Tasub tähele panna jutumärke argumendi position väärtuste ümber. Nimelt selle argumendi väärtust ei saa siduda mõne tunnusega andmestikus (poleks eriti mõttekas, et näiteks ühe osariigi erineva vaesustaseme tulbad paiknevad kõrvuti, teisel aga üksteise otsas). Üldse on argumendil position neli võimalikku väärtust:

• "dodge" – paneb elemendid üksteise kõrvale
• "fill" – skaleerib elemendid sama suureks (kasutatakse protsendiskaalat)
• "identity" – (vaikimisi) mitte midagi ei tehta
• "stack" – paneb elemendid üksteise otsa (kumulatiivsed summad)
• "jitter – nihutab elemente juhuslikult üles-alla, paremale-vasakule

Kui kujutaksime maakondi hajuvusdiagrammil, kus x-teljega seome osariigi ning y-teljega keskmise sissetuleku, siis sellisel joonisel oleksid paljud maakondi kujutavad punktid üksteise peal. Andes qplot(.) käsu argumendile position väärtuse position = "jitter", saame punkte natukene hajutada, nii et jooniselt on näha sissetulekute jaotus igas maakonnas:

qplot(x = State, y = per_capita_inc, data = mk, position = "jitter")

Võib-olla on “jitter” punktikesi natuke liiga palju laiali hajutanud. Andes argumendile position väärtuseks hoopis funktsiooni position_jitter(width=, height=), saame kontrollida, kui palju hajutamist horisontaal- ja vertikaalsuunal tehakse.

qplot(x = State, y = per_capita_inc, data = mk, position = position_jitter(width = 0.2))

4.4 Jooniste tüübid

Enamjaolt joonistab qplot(.) käsk just sellise joonise, nagu on soovitud – tunnuste tüübi põhjal saab see käsk aru, kas sooviti histogrammi või tulpdiagrammi. Ent mõnikord võib olla soov teistsugust joonist näha. Näiteks kui x-teljele panna diskreetne tunnus ja y-teljele pidev, siis vaikimisi joonistatakse hajuvusdiagrammilaadne joonis (iga objekt on kujutatud punktiga). Aga mõttekam on sellises olukorras hoopis kasutada karpdiagramme. Käsu qplot puhul saab argumendiga geom seda määrata:

qplot(State, per_capita_inc, data = mk, geom = "boxplot")

Meeldetuletus joonise tüüpide valikust:

Erinevaid elemente saab joonsel korraga kujutada (nt aegridade puhul):

time = 1:12
value = c(9, 4, 3, 5, 6, 8, 8, 15, 26, 29, 24, 23)
qplot(time, value, geom = c("point", "line"))

Joondiagrammi puhul saab argumendiga group öelda, milline tunnus määrab, millise joonega antud info kokku läheb.

# data.frame käsk aitab ise käsitsi andmestikku tekitada
d <- data.frame(grupp = rep(c("platseebo", "ravim"), each=5), 
                pulss = c(130, 125, 121, 124, 125, 131, 115, 99, 89, 82),
                arstivisiit = rep(1:5, 2))
qplot(arstivisiit, pulss, data = d, geom = "line", group = grupp, colour = grupp, ylim = c(0, 135))

Mõnikord harvem muidugi võib olla soov esitada pideva ja kategoorilise tunnuse vahelise seose kirjeldamiseks mitte karpdiagramme, aga näiteks keskmisi koos usaldusvahemikega. Sellistest keerukamatest võimalustest tuleb hiljem juttu.

4.5 Joonise jagamine tahkudeks

Sageli on mõistlik ühe suure ja kirju pildi asemel joonistada palju väikeseid sarnase sisuga pilte. Selmet erinevate osariikide maakondade vaesus ja haridustaseme seost ühel ja samal pildil kujutada, võiks seda iga osariigi jaoks teha eraldi. Käsus qplot(.) on selleks argument facets. Sellele argumendile tuleb väärtus anda nn valemi kujul: ridadeks_jagav_muutuja ~ veergudeks_jagav_muutuja. Kui üks neist ära jätta, siis selle asemele tuleks kirjutada punkt.

qplot(bachelor, perc_poverty, data = mk, facets = . ~ State)

Kui ridadeks jagava muutuja asemele punkti mitte panna, siis laotakse joonised kõrvuti ritta kuni rida saab täis; ülejäänud joonised pannakse järgmistesse ridadesse:

qplot(bachelor, perc_poverty, data = mk, facets = ~ State)

4.6 Joonisele kihtide lisamine

Paketiga ggplot2 koostatud jooniseid saab salvestada objektina; valmisolevaid jooniseid saab seetõttu lihtsasti muuta ja täiendada. Erinevalt baasgraafikast, kus joonise koostamiseks vajalik info tuleb anda ühe käsu piires või mitme täiesti eraldi käsuga, kasutatakse ggplot2 puhul käskude liitmist sümboliga + (see ilmestab paremini seda, kuidas joonis elementhaaval üles on ehitatud). Geomeetriliste elementide (punktid, jooned, tulbad jne) lisamiseks/muutmiseks on käsud geom_<elemendi_nimi>.

p <- qplot(x=per_capita_inc, y=unemployment_rate, data=mk) # tekitatakse joonise objekt, ei kuvata
p # kuvatakse joonis
p + geom_point(mapping = aes(colour = State)) # lisame punktidele värvi

Tasub tähele panna käsku aes(.) (nagu aesthetics), mis ülaloleval joonisel punktide värvimiseks geom_point(.) funktsiooni argumendile mapping ette anti. Nimelt aes(.) funktsioon aitab siduda graafilisi elemente andmestikus olevate tunnustega. Kui aes(.) funktsiooni ei kasutaks, otsitaks vastavate argumentide väärtuseid mitte andmestikust, vaid töökeskkonnast:

p + geom_point(colour = State) # objekti State otsitakse töökeskkonnast ja ei leita

## Error in do.call("layer", list(mapping = mapping, data = data, stat = stat, : object 'State' not found

Samas aga käsitsi mingi värvi etteandmiseks ei peaks aes(.) funktsiooni kasutama (sest muidu otsitakse seda värvi andmestikust).

p + geom_point(aes(colour = "green")) 

p + geom_point(colour = "green")

Joonisele saab lisada ka uusi elemente, näiteks regressioonikõveraid või teksti. Uute elementide lisamisel võib ette anda uue andmestiku argumendiga data:

p + geom_smooth(method = lm) + # lisatakse siluja (praegu lineaarne regressioon)
    geom_text(mapping = aes(label = County), size = 3, data = mk[c(34, 48, 65), ], 
              colour = "red", hjust = 1, vjust = 0)

Kordusmõõtmiste puhul joonistatakse sageli iga mõõtmisobjekti mõõtmistulemused eraldi tahkudele (facets). Et täita tahkudega mitu rida, saab kasutada käsku + facet_wrap(.) või anda qplot(.) käsu argumendile facets väärtuseks facets = ~ pop_deciles. Kui miskipärast on soov tahkudel kasutada erinevaid skaalasid, siis seda saab facet_wrap(.) argumendiga scale määrata:

mk$pop_deciles <- cut(mk$pop_estimate, quantile(mk$pop_estimate, seq(0, 1, 0.1)), 
                      labels = c("1.", "2.", "3.", "4.", "5.", "6.", "7.", "8.", "9.", "10."), 
                      include.lowest = TRUE)
qplot(white, births, data = mk) + facet_wrap(facets = ~ pop_deciles, scale = "free") 

4.7 Skaalade muutmine

Kui ggplot2-ga koostada joonis, siis muutujad seostatakse graafiliste elementide omadustega (asukoht x-teljel, asukoht y-teljel, värvus, suurus jne). Vaikimisi kasutatakse küllalt mõistlikke skaalasid, nt värviskaalad on valitud selliselt, et kõik värvid oleks võrdse intensiivsusega. Mõnikord on aga soov skaalasid muuta. Selleks saab kasutada käske scale_<graafilise elemendi nimi>_<skaala nimi>. Näiteks scale_x_continuous(.) käsuga saab muuta x-telje vahemikku, scale_colour_grey(.) muudab värviskaala mustvalgeks.

Kõiki skaalade muutmise funktsioone on võimalik näha ggplot2 kodulehel http://docs.ggplot2.org/current/index.html jaotuse “Scales” all.

Skaleerimisfunktsiooni rakendamiseks tuleb see lisada joonisele:

p2 <- qplot(per_capita_inc, unemployment_rate, colour = State, data = mk)
p2 + scale_x_continuous(trans = "log")

Iga erineva omaduse skaala muutmiseks saab joonisele “juurde liita” uue funktsiooni. Konkreetse funktsiooni parameetrid sõltuvad omaduse tüübist (nt punkti kuju ei saa logaritmida), aga on kõigil skaleerimisfunktsioonidel on kindlasti kolm argumenti:

• name – telgede puhul telje nimi; värvide, kuju jm legendis antava info puhul vastava legendi pealkiri
• breaks – vektor punktidega, mis määravad, millised väärtused joonisel ära markeeritakse (nt x-telje jaotis)
• labels – parameetriga breaks määratud punktidele vastavad sildid

p2  + scale_x_continuous(name = "Per capita income", breaks = c(10000, 40000),
                         labels = c("Low", "High")) +
      scale_colour_hue(name = "State name", breaks = c("Alaska", "Texas"))

Skaalasid (mh nende nimesid) saab muuta vastava scale-käsuga, ent mõned qplot(.) käsu argumendid muudavad selle natukene lihtsamaks:

• main – joonise pealkiri
• xlab, ylab – telgede pealkirjad
• xlim, ylim – kaheelemendilised vektorid, mis määravad telgede väärtusvahemiku.

p2 + scale_x_continuous(limits = c(10000, 20000)) + geom_smooth(method = lm)

qplot(State, unemployment_rate, geom = "boxplot", data = mk) +
   scale_x_discrete(limits = c("Texas", "Maryland"))  # pane tähele järjekorda

p3=qplot(per_capita_inc, unemployment_rate, colour = bachelor - mean(bachelor), data = mk) +
     scale_colour_gradient(name="% w/ higher \n education", low = "yellow", high = "red")
p3

4.8 Joonise viimistlemine

Vaikimisi joonistab ggplot2 halli taustaga jooniseid – et heledamad värvid oleksid sama silmatorkavad kui tumedad. Kui on soov valge tausta järele, siis seda saab tellida, lisades joonisele käsu + theme_bw(). Veelgi detailsemalt saab joonise kujundust käsuga + theme(.), mille argumentidest mõned olulisemad on:

Täielikum loetelu theme(.) võimalikest argumentidest on aadressil http://docs.ggplot2.org/current/theme.html .

Nagu näha, on kolm peamist elemenditüüpi, mida saab muuta käskudega element_text(.), element_line(.), ja element_rect(.). Nendel käskudel on omakorda argumendid:

• element_text(.) – family, size, colour, angle, hjust, vjust kontrollivad teksti šrifti, suurust, värvi, kaldenurka ja positsiooni vaikimisi määratud koha suhtes
• element_line(.) – colour, size, linetype;
• element_rect(.) – colour, size, linetype ääre muutmiseks, fill sisemuse värvi muutmiseks

Kui mõnda elementi üldse joonisel ei soovi näha, siis tuleb vastavale argumendile anda väärtus element_blank().

4.9 Joonise salvestamine

ggplot2-ga tehtud jooniseid saab salvestada käsuga ggsave(.). Kui anda käsule vaid faili nimi (koos laiendiga), siis salvestatakse viimati valmistatud joonis. Kui argumente widht ja height ei kasuta, siis joonise mõõtmed võetakse joonise akna järgi.

4.10 ggplot2 puudused

Kuna ggplot2 on paljude võimalustega suhteliselt uus pakett, siis on tal ka puuduseid. Olulisim puudus on vahest mittetäielik dokumentatsioon. Sageli häirib ka see, et identify(.) käsku ei saa kasutada andmestiku ridade identifitseerimiseks joonisel klikkides. Karpdiagrammi saab teha ainult vertikaalselt ning horisontaalseks tuleb see käsuga coord_flip(.) pöörata:

qplot(State, births, geom = "boxplot", data = mk) + coord_flip()

6.1 Sõne pikkus, sõnede kokkukleepimine ja eraldamine, alamsõne eraldamine

• Sõnede pikkust saab teada käsuga str_length(.).
• Sõnesid saab kokku kleepida üheks käsuga str_c(.), millel saab argumendiga sep määrata, milline sümbol pannakse kokkukleebitavate sõnede vahele. Kui käsule str_c(.) kirjutada argumendi collapse väärtuseks mingi sümbol, siis kleebitakse kõik sõned üheks ainsaks sõneks, mis on selle sümboliga eraldatud.
• Kokkukleebitud sõne saab tükeldada käsuga str_split(.), mille argumendiga pattern saab määrata, mis on tükkide eraldaja. Selle käsu tulemusena tekib list (sellest tuleb hiljem juttu), mida saab vektoriks muuta käsuga unlist(.). Kui str_split(.) käsule anda pattern = "", siis tükeldatakse sõna üksikuteks tähtedeks.
• Alamsõne eraldamiseks on stringr paketis käsk str_sub(.), mille argumentidega start ja end saab määrata alamsõne alguse ja lõpu tärgi indeksid. Andes neile argumentidele negatiivsed indeksi väärtused, jäetakse vastavast indeksist alates tähed ära sõne algusest või lõpust.
• stringr käsud käsitlevad sõnesid sellisena, et iga sõne alguses on tühisõne “”.

sõnad <- c("Õun", "Apelsin", "Porrulauk", NA, "")
str_length(sõnad)

## [1]  3  7  9 NA  0

str_c(sõnad, 1:5, sep = "=")

## [1] "Õun=1"       "Apelsin=2"   "Porrulauk=3" "NA=4"        "=5"

(x <- str_c(sõnad, 1:5, sep = "=", collapse = ". "))

## [1] "Õun=1. Apelsin=2. Porrulauk=3. NA=4. =5"

unlist(str_split(x, ". "))

## [1] "Õun=1"       "Apelsin=2"   "Porrulauk=3" "NA=4"        "=5"

str_split(sõnad, "")

## [[1]]
## [1] ""  "Õ" "u" "n"
## 
## [[2]]
## [1] ""  "A" "p" "e" "l" "s" "i" "n"
## 
## [[3]]
##  [1] ""  "P" "o" "r" "r" "u" "l" "a" "u" "k"
## 
## [[4]]
## [1] NA
## 
## [[5]]
## [1] ""

str_sub(sõnad, 1:4, 3:6)

## [1] "Õun" "pel" "rru" NA    ""

str_sub(sõnad, end = -3)

## [1] "Õ"       "Apels"   "Porrula" NA        ""

6.2 Alamsõne otsimine ja muutmine

Et teada saada, kas üks sõne sisaldub teises sõnes, saab kasutada käsku str_detect(.) argumendiga pattern. Juhul, kui on soov otsitava alamsõne teksti kujul leida, saab kasutada käsku str_extract(.). Et teada saada, millisel positsioonil asub otsitav alamsõne, võiks kasutada käsku str_locate(.), mis tagastab kõige esimesel positsioonil leitud alamsõne (kui sellist alamsõne üldse leidub) algus- ja lõpuindeksid matrix-tüüpi objektina (tuleb juttu hiljem). Kui tahame kätte saada kõigil positsioonidel olevate alamsõnede algus- ja lõpuindeksid, sobib käsk str_locate_all(.), mis tagastab listi.

str_detect(sõnad, pattern = "r")

## [1] FALSE FALSE  TRUE    NA FALSE

str_extract(sõnad, "r")

## [1] NA  NA  "r" NA  NA

str_locate(sõnad, "r")

##      start end
## [1,]    NA  NA
## [2,]    NA  NA
## [3,]     3   3
## [4,]    NA  NA
## [5,]    NA  NA

str_locate_all(sõnad, "r")

## [[1]]
##      start end
## 
## [[2]]
##      start end
## 
## [[3]]
##      start end
## [1,]     3   3
## [2,]     4   4
## 
## [[4]]
##      start end
## 
## [[5]]
##      start end

Mõnikord on sõnede alguses või lõpus liiga palju tühikuid, neid saab eemaldada käsuga str_trim(.). Käsuga str_pad(.) aga saab sõne algusesse või lõppu panna tühikuid (või muid sümboleid) juurde, nii et sõne saavutaks argumendiga width ette antud pikkuse.

str_trim("    siin on palju tühjust    ")
str_pad(sõnad[-4], width = 9, side = "both", pad = "_") # NA jäetakse vahele

## [1] "siin on palju tühjust"
## [1] "___Õun___" "_Apelsin_" "Porrulauk" "_________"

Kõige üldisem sõnede muutmise käsk on str_replace(.), mis proovib argumendiga pattern ette antud ja leitud mustrit asendada argumendiga replacement määratud mustriga; asendatakse ainult esimene leidumine. Kõiki leidumisi saab asendada käsuga str_replace_all(.)

str_replace(sõnad, pattern = "r", replacement = "l")
str_replace_all(sõnad, "r", "l")

## [1] "Õun"       "Apelsin"   "Polrulauk" NA          ""         
## [1] "Õun"       "Apelsin"   "Pollulauk" NA          ""

Kõigile stringr paketi käkudele võib argumentidega pattern ja replacement ette anda ka regulaaravaldisi⁸; R-is on kasutusel selline määratlus, nagu on kirjeldatud käsu regex(.) abifailis ?regex.

str_detect(sõnad, "r|l")  # püstkriips = OR
str_replace("telefoninumber: +372 55-549-85", "[a-zA-Z: ]*(\\+[0-9]*)*( )*(.*)", "(\\1) \\3")

## [1] FALSE  TRUE  TRUE    NA FALSE
## [1] "(+372) 55-549-85"

7.0.1 Ülesanded

1. Lisa isikute andmestikku veerg, mis sisaldaks iga inimese sünnikuupäeva.
2. Lisa veerg, mis annab inimese vanuse täisaastates tänasel päeval (aastas on ~365,25 päeva).

8.1 Andmestike ühendamine (mestimine)

Oleme tutvunud, kuidas andmestikust saab eraldada alamhulki (nt ridu, mis vastavad teatud kriteeriumitele). Uusi veerge saab data.frame-tüüpi objektile lisada nii dollarimärgi kui kantsulgude abil, kui anname ette uue veeru nime:

mk[, "taastootev"] <- mk$births > 2.1   # kas sündimuskordaja on suur?
mk$taastootev <- mk$births > 2.1

Mitut uut veergu või rida andmestikule lisada on lihtne cbind(.) ja rbind(.) käskudega. Neid kasutades tuleb olla ettevaatlik: lisatavas reas peab olema sama palju elemente kui on andmestikus veerge, sealjuures need elemendid peavad olema sobilikku tüüpi (eriti palju tekitab probleeme Factor-tüüpi veergu uute väärtuste lisamine); lisatavas veerus peab olema sama palju elemente kui on andmestikus ridu.

# teeme kaks vektorit (Factor ja character tüüpi):
suurus <- cut(mk$pop_estimate, c(0, 1000, 10000, 1000000, Inf), 
              labels = c("mikro", "väike", "keskmine", "suur"), include.lowest = T)
sooylekaal <- ifelse(mk$fem > 50, "F", "M")
# lisame need vektorid andmestiku lõppu veergudeks:
mk <- cbind(mk, suurus, sooylekaal)
# paneme andmestiku kaks korda üksteise otsa:
mktopelt <- rbind(mk, mk)

Sageli on analüüsiks vaja minevad andmed mitmes erinevas andmetabelis. Näiteks jooksuvõistluste andmete puhul võivad ühes tabelis kirjas isikuandmed kohta (nimi ja sugu), teises tabels aga nende isikute võistlustulemuste andmed. Kui sooviks analüüsida tulemuste jaotust sugude vahel oleks mugav need tabelid mestida käsuga merge(.).

isikud <- data.frame(nimi = c("Peeter", "Mari", "Tiina", "Laine"),
      sugu = c("M", "N", "N", "N"), vanus = c(30, 22, 25, 20))
tulemused <- data.frame(nimi = c("Mari", "Peeter", "Tiina", "Peeter"),
      tulemus = c(30.1, 22.5, 18.4, 25.3),
      voistlus = c("jooks1", "jooks1", "jooks2", "jooks2"))

isikud[order(isikud$vanus), ]

##     nimi sugu vanus
## 4  Laine    N    20
## 2   Mari    N    22
## 3  Tiina    N    25
## 1 Peeter    M    30

tulemused

##     nimi tulemus voistlus
## 1   Mari    30.1   jooks1
## 2 Peeter    22.5   jooks1
## 3  Tiina    18.4   jooks2
## 4 Peeter    25.3   jooks2

(kokku <- merge(isikud, tulemused, by = "nimi", all = TRUE))

##     nimi sugu vanus tulemus voistlus
## 1  Laine    N    20      NA     <NA>
## 2   Mari    N    22    30.1   jooks1
## 3 Peeter    M    30    22.5   jooks1
## 4 Peeter    M    30    25.3   jooks2
## 5  Tiina    N    25    18.4   jooks2

8.2 Unikaalsed ja mitmekordsed elemendid. Hulgatehted.

Mõnikord on üks objekt andmestikus mitu korda, ent me soovime seda ainult ühel korral analüüsi kaasata. Etteantud vektorist saab unikaalsed elemendid kätte käsuga unique(.). Käsuga duplicated(.) saab teada, kas ette antud vektoris on element esimest või juba mitmendat korda (tulemuseks on tõeväärtusvektor, kus TRUE tähendab seda, et antud väärtus on juba mitmendat korda).

kokku$nimi
unique(kokku$nimi)
duplicated(kokku$nimi)

## [1] Laine  Mari   Peeter Peeter Tiina 
## Levels: Laine Mari Peeter Tiina
## [1] Laine  Mari   Peeter Tiina 
## Levels: Laine Mari Peeter Tiina
## [1] FALSE FALSE FALSE  TRUE FALSE

R-is on realiseeritud ka elementaarsed hulgaoperaatorid: ühisosa, ühend ja vahe. Käsk union(x, y) tagastab ette antud kahe vektori x ja y elementidest koostatud uue vektori, sealjuures mõlema vektori kõik elemendid on esindatud. Käsk intersect(x, y) tagastab vektori elementidest, sealjuures on esindatud ainult need elemendid mis on nii vektoris x kui ka y. Käsk setdiff(x, y) tagastab vektori, kus on ainult need x elemendid, mida vektoris y ei ole. Kõik hulgatehete käsud tagastavad sellised vektorid, kus igat elementi on ainult üks kord

x <- c(1:5, 1:5)
y <- 3:7
union(x, y)

## [1] 1 2 3 4 5 6 7

intersect(x, y)

## [1] 3 4 5

setdiff(x, y)

## [1] 1 2

8.3 Sorteerimine

Väga sageli soovime, et andmestiku read oleks mingi tunnuse (nt inimese vanuse) alusel sorteeritud. Sorteerimiseks on R-is kaks olulist käsku: order(.) tagastab etteantud vektori elementide järjekorranumbrid sellises järjekorras, et saaksime järjestatud vektori, mh argumendiga decreasing saab määrata, kas see on kahanev või kasvav; sort(.) tagastab etteantud vektori elemendid kasvavas (või kahanevas) järjekorras.

x <- c(8, 1, NA, 7, 7)
order(x)

## [1] 2 4 5 1 3

sort(x, na.last = TRUE)

## [1]  1  7  7  8 NA

# saab ka mitme vektori järgi sortida:
kokku[order(kokku$vanus, kokku$tulemus, decreasing = TRUE), ] 

##     nimi sugu vanus tulemus voistlus
## 4 Peeter    M    30    25.3   jooks2
## 3 Peeter    M    30    22.5   jooks1
## 5  Tiina    N    25    18.4   jooks2
## 2   Mari    N    22    30.1   jooks1
## 1  Laine    N    20      NA     <NA>

8.4 Pikk ja lai andmetabel. reshape2

Tihti on väiksemat sorti uuringutes kogutud andmeid (nt Exceli vms abil) sellisel moel, et tekkivat andmetabelit oleks inimesel lihtne mõista: tegemist on nn laias formaadis andmestikuga, üks rida vastab ühele objektile, infoliiasus on viidud miinimumini. Näide laias formaadis andmestikust:

##   nimi kaal pikkus sugu pulss0m pulss10m pulss30m
## 1 Mari   68    170    2      70      130      150
## 2 Jaan   65    180    1      80      120      120
## 3 Jüri  100    190    1      80      190       NA

Pikas formaadis andmestiku puhul proovitakse hoida kõiki sama omadust kirjeldavaid andmeid ühes veerus; üks objekt võib kajastuda mitmel real. Sellisel kujul andmestikku on mõnikord mugav arvuti abil analüüsida (nt segamudelitega, ggplot2 ja lattice pakettidega):

##   nimi kaal pikkus sugu variable value
## 1 Mari   68    170    2  pulss0m    70
## 2 Jaan   65    180    1  pulss0m    80
## 3 Jüri  100    190    1  pulss0m    80
## 4 Mari   68    170    2 pulss10m   130
## 5 Jaan   65    180    1 pulss10m   120
## 6 Jüri  100    190    1 pulss10m   190
## 7 Mari   68    170    2 pulss30m   150
## 8 Jaan   65    180    1 pulss30m   120
## 9 Jüri  100    190    1 pulss30m    NA

Eriti äärmuslik on pika formaadi puhul hoida kõiki arvulisi tunnuseid ühes veerus:

##    nimi variable value
## 1  Mari     kaal    68
## 2  Jaan     kaal    65
## 3  Jüri     kaal   100
## 4  Mari   pikkus   170
## 5  Jaan   pikkus   180
## 6  Jüri   pikkus   190
## 7  Mari     sugu     2
## 8  Jaan     sugu     1
## 9  Jüri     sugu     1
## 10 Mari  pulss0m    70
## 11 Jaan  pulss0m    80
## 12 Jüri  pulss0m    80
## 13 Mari pulss10m   130
## 14 Jaan pulss10m   120
## 15 Jüri pulss10m   190
## 16 Mari pulss30m   150
## 17 Jaan pulss30m   120
## 18 Jüri pulss30m    NA

Kuigi R-i baaspaketis on kaasas käsk reshape(.), siis on sellega üsna tüütu teisendada andmestikku ühest formaadist teise. Seetõttu tutvume paketiga reshape2, milles olulisimad käsud melt(.) ja dcast(.) aitavad vastavalt teisendada andmestikku laiast formaadist pikka ja vastupidi, ning teha veel täiendavaid toiminguid/arvutusi.

Funktsioon melt(.) teisendab andmed laiast formaadist pikka. Argumendiga measure.vars saab sellele ette anda veerunimede või -indeksite vektori, milles olevad tunnused pannakse kõik ühte veergu. Vaikimisi pannakse kõik arvulised väärtused ühte veergu nimega value ning teises veerus nimega variable on kirjas, mida antud väärtus tähendab (millises veerus see väärtus esialgses andmestikus oli).

library(reshape2) # kui arvutis pole, siis installida: install.packages("reshape2")
library(ggplot2)
vr <- data.frame(nimi = c("Mari", "Jaan", "Jüri"), kaal = c(68, 65, 100), 
                 pikkus = c(170, 180, 190), sugu = c(2, 1, 1), pulss0m = c(70, 80, 80), 
                 pulss10m = c(130, 120, 190), pulss30m = c(150, 120, NA))
(m <- melt(vr, measure.vars = 5:7)) # välimised sulud tingivad ekraanile trükkimise
qplot(variable, value, data = m, geom = "line", group = nimi, facets = ~ nimi) +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))

##   nimi kaal pikkus sugu variable value
## 1 Mari   68    170    2  pulss0m    70
## 2 Jaan   65    180    1  pulss0m    80
## 3 Jüri  100    190    1  pulss0m    80
## 4 Mari   68    170    2 pulss10m   130
## 5 Jaan   65    180    1 pulss10m   120
## 6 Jüri  100    190    1 pulss10m   190
## 7 Mari   68    170    2 pulss30m   150
## 8 Jaan   65    180    1 pulss30m   120
## 9 Jüri  100    190    1 pulss30m    NA

Funktsioon dcast(.) aitab andmeid pikast formaadist laia teisendada, sealjuures tuleb argumendiga formula kindlasti ette öelda, millised tunnused määravad ära read ning millised määravad ära veerud: formula = reatunnus1 + reatunnus2 ~ veerutunnus1 + veerutunnus2. Väga kasulik on argument fun.aggregate, mille abil saab määrata, kas ja millist funktsiooni peaks kasutama veerutunnustega antud väärtuste agregeerimiseks. Funktsiooniga recast(.) saab korraga rakendada melt(.) ja seejärel dcast(.) käsku.

dcast(m, formula = nimi ~ variable)

##   nimi pulss0m pulss10m pulss30m
## 1 Jaan      80      120      120
## 2 Jüri      80      190       NA
## 3 Mari      70      130      150

dcast(m, nimi + kaal ~ variable + sugu)

##   nimi kaal pulss0m_1 pulss0m_2 pulss10m_1 pulss10m_2 pulss30m_1 pulss30m_2
## 1 Jaan   65        80        NA        120         NA        120         NA
## 2 Jüri  100        80        NA        190         NA         NA         NA
## 3 Mari   68        NA        70         NA        130         NA        150

dcast(m, nimi ~ . , fun.aggregate = mean, na.rm = TRUE, value.var = "value")

##   nimi        .
## 1 Jaan 106.6667
## 2 Jüri 135.0000
## 3 Mari 116.6667

#     (    dcast osa, melt osa         , dcast osa    )        -- tulemus sama, mis üleval
recast(vr, nimi ~ . , measure.var = 5:7, fun.aggregate = mean, na.rm = T)

9.1 Sisendi jagamine tükkideks

Kui sisendiks on list, siis seda saab jagada ainult elementideks.

Kui sisendiks on maatriks, siis seda saab jagada üksikuteks ridadeks või üksikuteks veergudeks, milleks tuleks a!ply(.) käsu argumendi .margins väärtuseks anda vastavalt 1 või 2.

Kui sisendiks on andmetabel (see on kõige tüüpilisem olukord), siis seda võib tükkideks jagada mingi tunnuse väärtuste alusel (nt haridustase) või erinevate tunnuste väärtuste kombinatsioonide järgi (nt sugu ja haridustase). Selleks tuleb d!ply(.) käsu argumendi .variables väärtuseks anda vastavate veergude nimed.

9.2 Teostatava funktsiooni määramine

Kui andmestik on jagatud tükkideks, siis peame neile rakendama mingit operatsiooni. Kõikidel ?!ply(.) funktsioonidel on argument .fun, millega saab määrata tükil rakendatava funktsiooni nime (ilma jutumärkide ja argumentideta). Tihtipeale on väga kasulikud lihtsad funktsioonid nagu length, nrow või mean. Kui need rakendatavad funktsioonid vajavad lisaargumente (nt na.rm), siis saab ka need ette anda.

library(plyr)
laply(vr[, 5:7], mean, na.rm = T) # data.frame on tegelikult list, elementideks veerud
# laply arvutab iga elemendi keskmise (sealjuures na.rm = T) ja tagastab vektori

## [1]  76.66667 146.66667 135.00000

Tihti soovime, et ühel tükil tehtaks mitu operatsiooni. Siis on võimalik ise koostada funktsioon (tutvume sellega hiljem) ja see argumendile .fun ette anda. Paketiga plyr on aga kaasas üks mugav funktsioon summarise(.), millele saab anda mitu erinevat funktsiooni ning määrata ära, kuidas nende funktsioonide tulemused nimetatakse:

# paneme kõik pulsi mõõtmistulemused ühte veergu
m <- melt(vr, measure.vars = 5:7) # reshape2::melt
# arvutame iga inimese keskmise ja minimaalse vererõhu
ddply(m, "nimi", summarise, keskmine = mean(value, na.rm = T), miinimum = min(value, na.rm = T))
#   (andmestik, kuidas tükeldada, summarise, arvutatava väärtuse nimi ja vastav funktsioon)

##   nimi keskmine miinimum
## 1 Jaan 106.6667       80
## 2 Jüri 135.0000       80
## 3 Mari 116.6667       70

9.3 Tulemuste ühendamine

Mistahes tüüpi tulemusi saab alati kokku panna ühte listi. Enamasti soovime väljundiks aga saada andmetabelit. Sellisel juhul argumendile .fun ette antav funktsioon peab tagastama data.frame tüüpi objekti (summarise(.) funktsioon seda ka teeb).

9.4 Näiteid

# Kuidas on tunnused jaotunud:
head(alply(mass, 2, summary))  # 2 näitab, et tahan töödelda igat VEERGU eraldi

## $`1`
##        id       
##  Min.   :    1  
##  1st Qu.:16639  
##  Median :32446  
##  Mean   :32453  
##  3rd Qu.:48477  
##  Max.   :64916  
## 
## $`2`
##       AGEP      
##  Min.   : 0.00  
##  1st Qu.:20.00  
##  Median :40.00  
##  Mean   :39.68  
##  3rd Qu.:56.00  
##  Max.   :94.00  
## 
## $`3`
##                                                   CIT      
##  Born abroad of American parent(s)                  :  62  
##  Born in Puerto Rico, Guam, the U.S. Virgin Islands,:  79  
##  Born in the U.S.                                   :5422  
##  Not a citizen of the U.S.                          : 448  
##  U.S. citizen by naturalization                     : 413  
## 
## $`4`
##                                              COW      
##  Employee of a private for-profit company or   :2635  
##  Employee of a private not-for-profit,         : 491  
##  Local government employee (city, county, etc.): 331  
##  Self-employed in own not incorporated         : 289  
##  State government employee                     : 157  
##  (Other)                                       : 229  
##  NA's                                          :2292  
## 
## $`5`
##    DDRS     
##  No  :5879  
##  Yes : 203  
##  NA's: 342  
## 
## $`6`
##       INTP       
##  Min.   : -9999  
##  1st Qu.:     0  
##  Median :     0  
##  Mean   :  3191  
##  3rd Qu.:     0  
##  Max.   :229000  
##  NA's   :1111

# Mitu puuduvat väärtust on igas veerus (defineerin ise uue funktsiooni):
aaply(mass, 2, function(x){return(sum(is.na(x)))})

##  AGEP   CIT   COW  DDRS   ESR    id  INDP  INTP  LANX   MAR MARHT   MIG   MIL  OCCP PINCP RAC1P 
##     0     0  2292   342  1182     0  2582  1111   342     0  2760    68  1274  2950  1111     0 
##  SCHL   SEX  WAGP  WKHP 
##  1095     0  1111  2678

# Erineva soo ja päritoluga inimeste arv, keskmine palk ja töötundide arv:
ddply(mass, c("SEX", "CIT"), summarise, 
           n = length(WAGP), palk = mean(WAGP, na.rm = T), tunde = mean(WKHP, na.rm =T))

##       SEX                                                 CIT    n     palk    tunde
## 1  Female                   Born abroad of American parent(s)   31 24903.85 32.94737
## 2  Female Born in Puerto Rico, Guam, the U.S. Virgin Islands,   46 13863.90 36.81818
## 3  Female                                    Born in the U.S. 2785 24878.65 34.72685
## 4  Female                           Not a citizen of the U.S.  211 21523.18 36.45082
## 5  Female                      U.S. citizen by naturalization  226 23148.67 35.92466
## 6    Male                   Born abroad of American parent(s)   31 32420.80 40.37500
## 7    Male Born in Puerto Rico, Guam, the U.S. Virgin Islands,   33 10842.42 39.84615
## 8    Male                                    Born in the U.S. 2637 43492.89 40.58805
## 9    Male                           Not a citizen of the U.S.  237 43005.05 43.07865
## 10   Male                      U.S. citizen by naturalization  187 40199.44 40.53731

9.5 Kasulikud lisafunktsioonid

Paketis plyr on veel paari tüüpi käske. r!ply(.) kordab suvalist R-i käsku etteantud arv kordi ja pärast ühendab tulemused; see on kasulik juhul, kui etteantavas käsus on midagi juhuslikku. m!ply(.) annab meid huvitavale funktsioonile ette erinevaid argumente, mis on andmetabelis antud.

# Tekitame viis korda kolme-elemendilist juhuarvude vektorit ning igast vektorist leiame
# minimaalse juhuarvu (standardnormaaljaotusest)
rdply(5, min(rnorm(3))) 

##   .n         V1
## 1  1 -0.7071305
## 2  2 -0.5669933
## 3  3 -2.5926963
## 4  4 -0.5292715
## 5  5 -1.1611932

# Tekitame listi, kus on kahe-elemendilised vektorid (kokku kolm vektorit)
rlply(3, rnorm(2))

## [[1]]
## [1]  0.5357281 -1.6853919
## 
## [[2]]
## [1] 0.7841608 1.6789122
## 
## [[3]]
## [1] 0.5114857 0.8497628

# Defineerime andmetabeli funktsiooni argumendi väärtustega:
argumendid <- data.frame(mean = c(0, 10, 100), sd = c(100, 10, 0))
# Genereerime viie-elemendilised vektorid meie poolt määratud normaaljaotuse parameetritega
mdply(argumendid, rnorm, n = 5)

##   mean  sd          V1        V2        V3        V4         V5
## 1    0 100 -66.7149416 184.59612 131.21062 -57.32150 -43.012547
## 2   10  10  -0.8540487  13.00069  22.44667  13.40243  -1.066437
## 3  100   0 100.0000000 100.00000 100.00000 100.00000 100.000000

10.1 dplyr pakett

dplyr pakett on paketi plyr käsu ddply(.) edasiarendus, aitamaks suuri andmestikke kiiremini töödelda/analüüsida. Põhjalik ülevaade selle paketi käskudest on paketi dokumentatsioonis¹⁰. Allpool on loetletud mõned kõige vajalikumad/kasulikumad käsud.

Käsk filter(.) aitab selekteerida teatud kriteeriumitele vastavaid ridu. See on kiirem kui kantsulgude kasutamine, sest kantsulgusid kasutades vaadatakse üksikud elemendid ükshaaval üle, ent filter(.) käsu puhul kasutatakse nutikamaid algoritme (enamasti andmed sorditakse mingil moel enne kui hakatakse üldse filtris määratud kriteerume kontrollima).

library(dplyr) # Kui pole, tuleb installida

## 
## Attaching package: 'dplyr'
## 
## The following objects are masked from 'package:plyr':
## 
##     arrange, count, desc, failwith, id, mutate, rename, summarise, summarize
## 
## The following object is masked from 'package:stats':
## 
##     filter
## 
## The following objects are masked from 'package:base':
## 
##     intersect, setdiff, setequal, union

# Võtame ainult mõned veerud (2=AGEP,14=WAGP) ja alles siis rakendame filtrit
filter(mass[, c(1, 2, 3, 12, 13, 14)], AGEP > 70, WAGP > 100000)

##      id AGEP                            CIT                                           SCHL  SEX
## 1  9452   84 U.S. citizen by naturalization Professional degree beyond a bachelor's degree Male
## 2 49277   71               Born in the U.S.                                Master's degree Male
## 3 64546   77               Born in the U.S. Professional degree beyond a bachelor's degree Male
##     WAGP
## 1 150000
## 2 110000
## 3 145000

Käsk group_by(.) aitab andmestiku tükkideks jagada, aga ei tee sellega midagi enamat. Kui tükkidel soovida midagi analüüsida, tuleb see ette anda vastavaks analüüsiks kasutatavale funktsioonile. Mugav funktsioon on jällegi dplyr paketiga kaasas olev summarise(.):

mass <- group_by(mass, CIT)
summarise(mass, keskpalk = mean(WAGP, na.rm = T))

## Source: local data frame [5 x 2]
## 
##                                                   CIT keskpalk
## 1                   Born abroad of American parent(s) 28588.63
## 2 Born in Puerto Rico, Guam, the U.S. Virgin Islands, 12516.49
## 3                                    Born in the U.S. 33829.36
## 4                           Not a citizen of the U.S. 32797.35
## 5                      U.S. citizen by naturalization 30703.34

Lisaks on paketis dplyr defineeritud toru ehk aheldamisoperaator (Unixi käsurealt tuttav püstkriips |), millega on võimalik ühe funktsiooni tulemused edasi anda järgmisele funktsioonile. Toru kasutamine aitab mõnikord muuda koodi loetavamaks. Aheldamisoperaatori kuju dplyr paketis on %>%.

# Andmestiku 'mass' grupeerime kodakonsuse, soo ja perekonnaseisu kaupa ning
# iga grupi jaoks arvutame keskmise palga (kokku 48 grupp), lõpuks võtame 6 esimest rida
mass %>% group_by(CIT, SEX, MAR) %>% summarise(keskpalk = mean(WAGP, na.rm = T)) %>% head()

## Source: local data frame [6 x 4]
## Groups: CIT, SEX
## 
##                                 CIT    SEX                                 MAR keskpalk
## 1 Born abroad of American parent(s) Female                            Divorced 37333.33
## 2 Born abroad of American parent(s) Female                             Married 16416.67
## 3 Born abroad of American parent(s) Female Never married or under 15 years old 39071.43
## 4 Born abroad of American parent(s) Female                           Separated 32500.00
## 5 Born abroad of American parent(s) Female                             Widowed     0.00
## 6 Born abroad of American parent(s)   Male                             Married 44660.00

10.2 Paralleelarvutus

Üldiselt jookseb R ühe protsessina – see tähendab, et kõige jaoks, mida R teeb, kasutatakse ainult üht protsessorituuma. Kui arvuti võimaldab ning andmestiku tükkide analüüsis on iga tükk sõltumatu, on mõistlik (eriti suuremate andmestike puhul) kasutada paralleelarvutuse võimalusi: mitmetuumalise protsessori iga tuum panna tegelema omaette andmetükiga. R-is on mitmeid lisapakette, mis aitavad ligi pääseda korraga mitmele protsessorituumale. Meie kasutame paketti doParallel. Kui see pakett on paigaldatud, saab käsu ddply(.) argumendile .parallel anda väärtuseks TRUE.

library(doParallel) # kui pole, tuleb installeerida; vajab veel ka teisi pakette
# Avame ligipääsu kõigile tuumadele:
registerDoParallel()
# Kasutame paralleelarvutust ddply käsuga, sel juhul tuleb kasutatav
# abifunktsioon ise defineerida
ddply(mass, c("SEX", "CIT"), .parallel = TRUE, .fun = function(df){
  return(data.frame(keskmine = mean(df$WAGP, na.rm = T)))
})
stopImplicitCluster() # Sulgeme tuumad

##       SEX                                                 CIT keskmine
## 1  Female                   Born abroad of American parent(s) 24903.85
## 2  Female Born in Puerto Rico, Guam, the U.S. Virgin Islands, 13863.90
## 3  Female                                    Born in the U.S. 24878.65
## 4  Female                           Not a citizen of the U.S. 21523.18
## 5  Female                      U.S. citizen by naturalization 23148.67
## 6    Male                   Born abroad of American parent(s) 32420.80
## 7    Male Born in Puerto Rico, Guam, the U.S. Virgin Islands, 10842.42
## 8    Male                                    Born in the U.S. 43492.89
## 9    Male                           Not a citizen of the U.S. 43005.05
## 10   Male                      U.S. citizen by naturalization 40199.44

Paketis parallel (mida kasutab ka pakett doParallel) on veel mõned paralleelarvutuseks soblikud käsud – mclapply(.) ja mcmapply(.) –, mis teostavad tuumade registreerimise ja töö peatamise automaatselt, samas nõuab nende käskude süntaks natukene peamurdmist.

Paralleelarvutuse võimalusi on mõistlik kasutada just suurte andmestike puhul. Kahjuks nõuab see ka aga mõnevõrra suuremat töömälu (erinevad tuumad tekitavad töödeldavast andmestikust omale isiklikud koopiad). Eriti gigantsete andmete puhul tasub kaaluda SQL-päringuid. R-i jaoks on mitmeid pakette, mis võimaldavad ligi pääseda SQL-andmebaasidele ning neist SQL-i või R-i lausetega väljavõtteid teha. Samuti on mõned paketid, mis muudavad data.frame tüüpi objekti sisuliselt SQL-andmebaasiks ning seetõttu aitavad selliseid andmetabeleid kiiremini töödelda. Üks viimase aja populaarne pakett on data.table¹¹.

11.1 Tsüklid

Tsükkel on programmikonstruktsioon, mis kordab teatud tegevust mitu korda järjest. See on kasulik näiteks siis, kui tahame vektori elemendid ükshaaval järjest üle vaadata ja vastavalt elemendi väärtusele midagi teha. R-is on võimalik kasutada kahte tüüpi tsükleid:

• for-tsükkel teeb ettemääratud arvu samme. Tsükli defineerimisel antakse ette mingi vektor, mille elemente ükshaaval hakatakse läbi käima. Enamasti koosneb see vektori järjestikustest täisarvudest, näiteks täisarvudest 1:10.

for (i in 1:10) {  # NB! siinne in on ilma protsendimärkideta!
  print(i)
}

for (loom in c("kass", "kaamel", "kilpkonn", NA, "kaan")) {
  print(loom)
}

• while-tsüklit korratakse seni, kuni teatud tingimus saab täidetud. Nn peatumistingimus tuleb kindlasti tsükli defineerimisel ette anda, sealjuures tuleb tsükli kirjutamisel olla ettevaatlik, et tsükkel lõpmatult kaua korduma ei jääks. while-tsükkel on kasulik siis, kui realiseerida mingit algoritmi, mille peatumine sõltub algoritmi koondumisest. Lõpmatu kordumise ohu vältimiseks on mõistlik tsükli päisesse lõpetamistingimuste hulka lisada tsüklisammude loendur.

a <- 1
while(a < 10) {
  print(a)
  a <- a + 1  # kui seda rida poleks, jääks tsükkel lõpmatult korduma
}

11.2 Tingimuslause if

Nagu praktiliselt kõigis programmeerimiskeeltes, on ka R-is tingimuslause if, millega saab kontrollida erinevate loogiliste tingimuste kehtimist ja vastavalt sellele, kas tulemus on TRUE või FALSE, rakendada erinevaid tegevusi. if-ploki sisu täidetakse juhul, kui tingimuse väärtus on TRUE; võib defineerida ka else-ploki, mis täidetakse siis, kui if-tingimuse väärtus on FALSE.

if (väärtus %% 2 == 0) {
  print(väärtus)
} else {              # kui else-lauset kasutada, peab see olema if-lause suluga samal real
  print(väärtus * 10)
}

Meenutuseks mõned olulisemad võrdlustehted:

• == – kahe elemendi võrdsus
• != – kahe elemendi erinevus
• <, <= – kas üks element on väiksem (või võrdne) kui teine
• >, >= – kas üks element on suurem (või võrdne) kui teine
• %in% – kas vasakpoolne element kuulub parempoolse vektori elementide hulka
• is.na(.) – kas väärtus on NA
• is.factor(.), is.numeric(.), is.character(.), is.logical(.) – kas objekt on antud tüüpi

Sageli tasub if lause tingimuste hulka lisada ka väärtuse või tüübi kontrollimine.

if (!is.na(väärtus) & is.numeric(väärtus) & väärtus %% 2 == 0) {  }

Kui if-ploki sisu on üherealine, võib loogelised sulud ka ära jätta. Samuti võib mitu käsku kirjutada ühele reale, eraldades need semikooloniga. Üldiselt aga pole see koodi loetavuse seisukohast soovitatav.

Kasulikud on ka ifelse(.) ja switch(.) käsud. ifelse(.) esimene argument on tõeväärtusvektor, teine arugment tulemus, mis vastab tõesele väärtusele, ja kolmas, mis vastab väärale väärtusele. switch(.) käsu esimene argument on tavaliselt täisarv (ainult üks täisarv!) ning ülejäänud argumendid erinevatele täisarvudele vastavad toimingud (kasvavas järjekorras).

table(  ifelse(is.na(andmed$WAGP), "palgatu", "palgaga")  )

11.3 Funktsioonide defineerimine

Uusi käske ehk funktsioone saab R-is tekitada funktsiooni function(.){.} abil. Funktsiooni päises on võimalik defineerida ja vaikeväärtustada argumendid, mida see funktsioon töö jaoks vajab. Argumendina võib defineerida/kasutada mistahes objekti, k.a mingit muud funktsiooni. Loogeliste sulgude vahel paiknevas funktsiooni kehas tuleb kirjeldada, mida teha nende argumentidega, mis funktsiooni päises on defineeritud. Hea tava on see, et funktsioon toimetab ainult nende objektidega, mis päises on defineeritud, ega muuda funktsiooniväliseid objekte.

minukäsk <- function(argument1, argument2 = "tere", argument3 = mean, ...) {
  # funktsiooni sisu
  tagastatav_objekt <- argument3(argument1, ...)
  return(tagastatav_objekt)
}

Enamjaolt on soov, et funktsioon tagastaks midagi käsu return(.) abil. Kui funktsioon midagi tagastama ei pea, ei pea return(.) käsku kirjutama (siiski tagastatakse sel juhul viimase käsu tulemus).

Funktsiooni argumentidel võivad olla vaikeväärtused (nagu argument2 = "tere"), ent sageli on vähemalt ühe argumendi väärtus vaja ette anda (antud näites on vaja kindlasti määrata argument1 väärtus). Argumentideks võivad olla ka funktsioonid (praeguses näites argument3 = mean). Eriline argument on ..., millega saab võimaldada teiste argumentidena kasutatavate funktsioonide lisaargumentide väärtuste.

minukäsk(argument1 = 1:6, argument3 = mean, na.rm = T) # argument na.rm saadetakse käsule mean
minukäsk(1:6, , min)

12.0.1 Ülesanne

1. Kirjuta funktsioon, mis genereerib kasutaja poolt määratud mõõtmetega arvutabeli (maatriksi) Poissoni jaotusest arvudega.
2. Kirjuta funktsioon, mis ette antud 2x2 maatriksi põhjal teeb hii-ruut testi ja tagastab vastava p-väärtuse.

14.1 Ülesanded

1. Loe sisse andmestik WB.txt aadressilt http://kodu.ut.ee/~maitraag/rtr/. (NB! pane tähele kuidas on tähistatud tühjad lahtrid)
2. Andmeid vaadates on näha, et osade riikide kohta on süstemaatiliselt andmed puudu.
   • Kui palju neid riike on?
   • Tekita uus andmestik, kus neid riigid on välja visatud. Kasuta selle ülseande täitmiseks tunnust Population.
3. Mitu erinevat regiooni on esindatud selles andmestikus? Kui palju erinevaid riike igast regioonist on?
4. Kuidas on jaotunud riigid regiooni ja jõukuse kaupa?
5. Tekita tunnus nn naftariikidest ja neist kellel seda pole (tunnuse Oil väärtus peab olema suurem kui 0)
6. Kuidas jagunevad naftariigid regioonide kaupa?
7. Millised on Lõuna-Aasia regiooni naftariigid?
8. Tunnus Total.wealth näitab riigi kõikide varade summat inimese kohta. Arvutage keskmine varade maht inimese kohta üle kõigi riikide. (Vihje: lihtsalt keskmise võtmine annab kallutatud tulemusi, kuna rahvaarv riikides on erinev.)
9. Arvutage nüüd keskmine varade maht elaniku kohta kõigis regioonides eraldi. Lisaks näidake sealjuures ära ka iga regiooni rahvaarv.
10. Joonistage graafik, mis võrdleb riikide produtseeritud kapitali ja loodusvarades peituvat kapitali. Kas joonistub välja mingi trend?
11. Proovige lisada pildile ka riikide sissetuleku grupid.
12. Lisage pildile ka mõnede huvitavamate riikide nimed.
13. Eralda andmestikust veerud Region, Population, Natural.Capital, Intangible.Capital ja Produced.Capital. Leia nagu ennegi iga maailmajao keskmine inimese kohta kõigi sõna “Capital” sisaldava nimega suuruste jaoks. Joonista tulemused välja tulpdiagrammina, kus on üks tulp iga regiooni kohta ja tulba kõrgus näitab kolme erineva kapitalitüübi summat ja värvidega on näidatud eri kapitalitüüpide osakaalud.