Uvod v R: Osnovni podatkovni tipi

Skalarji (angl. scalars)

R ima štiri osnovne tipe skalarjev oziroma njihovih vrednosti:

• Logični vrednosti (angl. logical) sta TRUE in FALSE ali na kratko T in F.

• Celoštevilske (angl. integer) vrednosti zapišemo kot številko, ki ji sledi simbol L, npr. 123456L. Če je celoštevilska vrednost prevelika ali premajhna (po absolutni vrednosti večja od .Machine$integer.max, na mojem računalniku je to 2,147,483,647) ali smo ji pomotoma dodali decimalke (in torej ni več celoštevilska), jo R avtomatsko pretvori v numerično vrednost (glej naslednjo alinejo).

• Numerične vrednosti (angl. double) v plavajoči vejici (angl. floating point) lahko zapišemo v navadni 123.456 ali znanstveni notaciji 1.23456e2. Tri posebne numerične vrednosti so -Inf, npr. -1/0, Inf, npr. 1/0, in NaN, npr. 0/0.

• Nize znakov (angl. string) zapišemo med enojne ' ali dvojne " narekovaje. Če niz znakov vsebuje narekovaje, slednje zapišemo s predpono \, npr. "To je primer niza znakov z \"narekovaji\"". Dolžina niza znakov je število znakov v nizu. Prazen niz znakov "" ima dolžino 0.

Spremenljivki v R-ju dodelimo (novo) skalarno vrednost z operatorjem <-. Gre za tradicionalni zapis, iz časov nastanka programskega okolja R. Danes R omogoča uporabo običajnega operatorja =, ki ga poznamo iz drugih programskih jezikov.

Po dodelitvi, tip spremenljivke se spremeni v tip skalarne vrednosti, ki ji jo dodelimo. Pri izračunih, ki vključujejo vrednosti in spremenljivke različnih tipov, se tipi dinamično (samodejno, v terminologiji R tudi prisilno, angl. coercion) in po potrebi prilagodijo tako, da bo izračun možno izpeljati. Prisilno prilagajanje tipov vedno poteka v smer, ki jo nakazuje vrstni red naštevanja štirih tipov zgoraj: logična vrednost se pretvori v celoštevilsko, ta nato v numerično (plavajočo vejico), ter na koncu še (seveda po potrebi) v niz znakov.

Pozor, prilagajanje tipov včasih tudi (neprijetno) preseneti, npr. 1 == "1" (operator == preveri, če sta izraza na levi in desni strani enaka). Izraz, ki bi lahko bil rezultat programske napake, R brez težav (prijavljanja napak ali opozoril) ovrednoti v TRUE in ne v morebiti bolj pričakovano vrednost FALSE (prepričaj se, da je temu tako, nato premisli in pojasni zakaj).

Tip poljubne spremenljivke, vrednosti ali izračuna, lahko preverimo s funkcijo typeof. Primer, ki ponazori samodejno pretvorbo med različnimi osnovnimi tipi:

x = 1L + TRUE
x

[1] 2

typeof(x)

[1] "integer"

x = 1L + TRUE + 1
x

[1] 3

typeof(x)

[1] "double"

x = !x
x

[1] FALSE

typeof(x)

[1] "logical"

Zamenjavo tipa vrednosti lahko sami sprožimo s funkcijami as.logical, as.integer, as.double in as.character. S temi funkcijami lahko preverimo kako R pretvarja oz. prilagaja tipe skalarjev. Med zanimivimi klici te funkcije sodijo npr. as.logical(0), as.character(FALSE), as.integer(2.8). Preden poskusite ukaze, preverite, ali znate pravilno napovedati njihovo delovanje.

Še ena, zelo pomembna skalarna vrednost je neznana vrednost NA. Bodite pozorni na naslednji dve dejstvi (zakaj je temu tako?):

NA == 0

[1] NA

NA == NA

[1] NA

Bodite pozorni: neznana vrednost NA je “kužna”. V večini primerov je vrednost izraza (izračuna), ki vključuje NA, enaka NA. Poznamo le nekaj redkih izjem, npr. NA & FALSE, NA | TRUE in NA ^ 0. Znova premisli zakaj je temu tako.

Za preverjanje ali je vrednost spremenljivke ali izraza neznana uporabimo funkcijo is.na. Na voljo so tudi štiri podobne funkcije s katerimi lahko preverimo, če je izraz nekega določenega tipa: is.logical, is.integer, is.double in is.character. Rezultati vseh teh funkcij so logične vrednosti.

Naj na tem mestu omenimo še oznako NULL, ki v R-ju nakazuje odsotnost vrednosti. Za razliko od NA, ki nakazuje prisotnost vrednosti, ki pa ni znana.

NULL == NULL

logical(0)

NULL == 0

logical(0)

NULL == NA

logical(0)

V vseh treh primerih je rezultat logical(0), kar je oznaka za prazen vektor logičnih vrednosti. Podobno kot NULL tudi prazen vektor nakazuje odsotnost vrednosti. Zadnja dva stavka omenjata podatkovni tip vektor, ki ga tudi štejemo med osnovnimi podatkovnimi tipi v R-ju. Spoznali ga bomo v nadaljevanju.

---

Vektorji (angl. vectors, atomic vectors)

Vektor predstavlja urejen seznam skalarjev istega tipa. Skalarje imenujemo elementi ali komponente seznama. Urejenost seznama pomeni, da je vrstni red elementov pomemben in lahko elemente naslavljamo na osnovi njihove pozicije v seznamu (urejenost namreč ne pomeni, da so elementi urejeni po naraščajoči ali padajoči vrednosti). Z drugimi besedami, znamo povedati kateri element seznama je prvi, drugi ali zadnji.

Vektorje najbolj preprosto ustvarjamo s klicem funkcije c, ki sprejme poljubno število argumentov in iz njih sestavi seznam. Dolžino vektorja, ki je enaka številu njegovih elementov, nam vrne funkcija length. Vektor dolžine 0 imenujemo prazen vektor. Že omenjena funkcija typeof pa nam vrne tip elementov vektorja (ne pozabimo, da so vsi elementi vektorja enakega tipa).

vl = c(TRUE, FALSE, TRUE, TRUE)
typeof(vl)

[1] "logical"

vi = c(-20L, -10L, 0L, 10L, 20L)
length(vi)

[1] 5

vd = c(-1, 2.5, 3)
as.integer(vd)

[1] -1  2  3

vs = c("nekaj stringov (ups, nizov znakov)", "za primer", "pa še številka", "42")
x = as.double(vs)

Warning: NAs introduced by coercion

x

[1] NA NA NA 42

is.na(x)

[1]  TRUE  TRUE  TRUE FALSE

Bodimo posebej pozorni na zadnje tri rezultate. Pri pretvarjanju nizov znakov v numerične vrednosti, Tiste nize znakov, ki se jih ne da (oziroma jih R ne zna) pretvoriti v numerične vrednosti, R pretvori v neznane vrednosti NA. Pri tem izpiše opozorilo (angl. warning) Neznane vrednosti NA vpeljane s (prisilnim) prilagajanjem tipov (angl. NAs introduced by coercion).

Poglejmo še kaj se zgodi, če poskusimo sestaviti vektor iz vrednosti različnih tipov:

x = c(TRUE, 1L)
x

[1] 1 1

typeof(x)

[1] "integer"

x = c(FALSE, 1, 2L)
x

[1] 0 1 2

typeof(x)

[1] "double"

x = c(TRUE, 1, 2.5)
x

[1] 1.0 1.0 2.5

typeof(x)

[1] "double"

x = c(FALSE, 1, 2L, "3")
x

[1] "FALSE" "1"     "2"     "3"    

typeof(x)

[1] "character"

Premislite in pojasnite zakaj so tipi teh vektorjev taki kot so?

Čeprav vektorji predstavljajo le enodimenzionalne sezname vrednosti istega tipa, z njimi lahko predstavimo tudi dvodimenzionalne matrike ali polja (tenzorje) poljubnega števila dimenzij. Zato da razumemo kako, spoznajmo najprej koncept vektorskih atributov.

Atributi vektorjev in matrike

Atributi so urejeni pari oblike (ime, vrednost), ki vektorje označijo z meta podatki. Za nastavljanje vrednosti atributov vektorja uporabljamo funkcijo attr, ki jo lahko tudi uporabimo za preverjanje vrednosti atributa. Funkcija attributes vrne vse atribute podanega vektorja.

v = c(-20L, -10L, 0L, 10L, 20L)

attr(v, "prvi_atribut") = 1
attr(v, "drugi_atribut") = 2.3

print("Prvi atribut vektorja v")

[1] "Prvi atribut vektorja v"

attr(v, "prvi_atribut")

[1] 1

print("Vsi atributi vektorja v")

[1] "Vsi atributi vektorja v"

attributes(v)

$prvi_atribut
[1] 1

$drugi_atribut
[1] 2.3

Rezultat funkcije attributes pravzaprav seznam atributov in njihovih vrednosti. R-jevsko podatkovno strukturo seznam bodo spoznali pozneje. Pozor: Vektorji v R-ju so podatkovna struktura, ki je podobna strukturi seznam v Python-u.

Funkcija structure omogoča dodajanje atributov že ob tvorjenju vektorja:

v = structure(
  c(-20L, -10L, 0L, 10L, 20L),
  prvi_atribut = 1,
  drugi_atribut = 2.3
)
v

[1] -20 -10   0  10  20
attr(,"prvi_atribut")
[1] 1
attr(,"drugi_atribut")
[1] 2.3

attributes(v)

$prvi_atribut
[1] 1

$drugi_atribut
[1] 2.3

Atributi so začasni. Mnoge funkcije in operacije nad seznami izbrišejo (pozabijo) atribute, preizkusite npr. v[1] ali sum(v):

attributes(vi[1])

NULL

attributes(sum(vi))

NULL

Vrednost izraza v[1] je enaka vrednosti prvega elementa vektorja v. Funkcija sum vrne vsoto vrednosti elementov podanega vektorja.

Dva atributa imajo v R-ju poseben pomen:

• names je vektor nizov znakov, ki je enake dolžine kot originalni vektor. Vsak element vektorja names določa ime elementa originalnega vektorja.
• dim je vektor celoštevilskih vrednosti, ki pretvori vektor v matriko ali polje.

Poimenovan vektor je vektor v katerem ima vsak element svoje ime. Imena elementov vektorja lahko nastavimo na vsaj dva načina: pri tvorjenju vektorja ali pa naknadno za navadni vektor z uporabo funkcije names:

x1 = c(prvi = 1, drugi = 2, tretji = 3)
x1

  prvi  drugi tretji 
     1      2      3 

x2 = c(1, 2, 3)
names(x2) = c("prvi", "drugi", "tretji")
x2

  prvi  drugi tretji 
     1      2      3 

Funkcijo names vrne imena elementov v poimenovanem seznamu. Preverite kaj vrne funkcija names za neimenovan seznam, npr. names(c(1,2,3)). Poimenovan seznam lahko spremenimo v neimenovanega (torej v vektor z elementi brez imen) s klicem funkcije unname:

x3 = unname(x2)
x3

[1] 1 2 3

Dimenzije vektorja, t.j., vrednost atributa dim določimo lahko pri tvorjenju vektorja ali naknadno z uporabo funkcije dim:

x = c(1, 2, 3, 4, 5, 6)

A1 = matrix(x, nrow = 2, ncol = 3)
A1

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

dim(A1)

[1] 2 3

A2 = x
dim(A2) = c(3, 2)
A2

     [,1] [,2]
[1,]    1    4
[2,]    2    5
[3,]    3    6

Tvorjenje vektorjev

Oglejmo si nekaj načinov za tvorjenje vektorjev:

• i:j je celoštevilski vektor z elementi i, i+1, ..., j, če je j >= i oziroma elementi i, i-1, \ldots, j, če je j < i.

• seq(from = i, to = j, by = s) je vektor numeričnih vrednosti, kjer je prvi element i, razlika med dvema zaporednima elementoma je s, zadnji element pa ne sme preseči vrednosti j. Pri različici seq(from = i, to = j, length.out = n) namesto razlike med zaporednima elementoma določimo število elementov, ki se ekvidistančno (enakomerno) razporedijo na intervalu [from, to].

• rep(v, times = n) je vektor sestavljen tako, da elemente v ponovimo n-krat. Če je v skalar, je dolžina dobljenega vektorja n, če pa je v vektor, je dolžina dobljenega vektorja n * length(v). Pri različici rep(v, each = n) določimo kolikokrat ponovimo vsak posamezen element v.

• sample(v, n) je vektor dolžine n (imenujemo ga vzorec), katerega elementi so naključno izbrani elementi vektorja v. Posamezen element iz v se lahko v vzorcu pojavi le enkrat. Posledica tega je, da je predpogoj za uspešno vzorčenje length(v) >= n. Različica sample(v, n, replace=T) opravi vzorčenje s ponavljanjem, kjer je posamezen element v se lahko v vzorcu pojavi tudi večkrat.

Poigraj se z naslednjimi primeri:

-1:13

 [1] -1  0  1  2  3  4  5  6  7  8  9 10 11 12 13

13:-1

 [1] 13 12 11 10  9  8  7  6  5  4  3  2  1  0 -1

13:13

[1] 13

seq(from = 0.5, to = -0.5, by = -0.1)

 [1]  0.5  0.4  0.3  0.2  0.1  0.0 -0.1 -0.2 -0.3 -0.4 -0.5

seq(from = -0.5, to = 0.5, length.out = 4)

[1] -0.5000000 -0.1666667  0.1666667  0.5000000

rep(-1:1, times = 3)

[1] -1  0  1 -1  0  1 -1  0  1

rep(-1:1, each = 3)

[1] -1 -1 -1  0  0  0  1  1  1

sample(-10:10, 12)

 [1]  2 -1  5 -9  7  3 -4  1  4 -8  6 10

sample(-10:10, 12)

 [1]  -6  10   8  -3  -5  -7 -10  -8   7   9   6   1

# sample(-10:10, 24): pojasni napako, ki jo javi ta klic funkcije sample

sample(1:6, 10, replace=T)

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

Indeksiranje vektorjev

Indeks elementa v vektorju v ustreza njegovi poziciji v urejenem seznamu. Tako je indeks prvega elementa vektorja 1, drugega 2, in tako naprej, vse do indeksa zadnjega elementa. Ta je enak dolžini vektorja length(v). Pozor: to je, poleg poimenovanja vektorjev, še ena pomembna razlika med R-jem in programskim jezikom Python, ki nas pogosto zmede. V Pythonu je indeks prvega elementa seznama 0, drugega 1 in zadnjega len(v) - 1.

Posamezen element vektorja v naslovimo z izrazom v[i] za poljuben element i celoštevilskega vektorja 1:length(x). Tako naslovljenemu elementu lahko dodelimo novo vrednost z v[i] = nova_vrednost ali pa ga uporabimo v poljubnem izrazu, npr. v[i] + 2. Tako indeksiranje in naslavljanje posameznega elementa vektorja pozna tudi večina drugih programskih jezikov. Za razliko od slednjih, R ponuja še veliko drugih možnosti indeksiranja, ki jih bomo spoznali v nadaljevanju. Fleksibilnost indeksiranja vektorjev je ključnega pomena pri uporabi R-ja za podatkovno analizo.

Poglejmo štiri načine naslavljanja poljubnega števila elementov vektorja v. Vsi so oblike v[vi], kjer je v vektor katerega elemente indeksiramo in vi vektor indeksov.

• Elementi vi so pozitivna cela števila: rezultat indeksiranja je vektor elementov vektorja v, katerih indeksi v v so elementi vektorja vi. Element i indeksa se lahko tudi večkrat ponovi v vektorju indeksov vi. To povzroči, da se tudi element v[i] pojavi večkrat v rezultatu indeksiranja.

• Elementi vi so negativna cela števila: rezultat indeksiranja je vektor elementov v, katerih indeksi niso elementi vektorja absolutnih vrednosti elementov vi. Z drugimi besedami element -i v vektorju indeksov vi povzroči, da element v[i] ni element rezultata indeksiranja.
  
  Pozor: Pozitivnih in negativnih celoštevilčnih vrednosti indeksov v vektorju vi ne smemo kombinirati.

• Elementi vi so logične vrednosti: rezultat indeksiranja je vektor elementov v za katere imajo enako-ležeči elementi vi vrednost TRUE. Običajno sta vektorja v in vi enakih dolžin. Če je vektor vi daljši od vektorja v, se pri indeksiranju upošteva le prvih length(v) njegovih elementov. Če je vektor vi krajši od vektorja v, se njegovi elementi reciklirajo, kot bo opisano v ustrenzem razdelku spodaj.

• Elementi vi so nizi znakov: rezultat indeksiranja je vektor elementov imenovanega vektorja v, katerih imena so v seznamu vi. Če se ime i v vektorju vi pojavi večkrat, se tudi v rezultatu indeksiranja element v[i] pojavi večkrat.

Pozor: neznana vrednost NA v vektorju indeksov vi vedno vrne element NA.

Dva posebna primera indeksiranja sta v[], katerega rezultat je enak v ter v[0], katerega rezultat je prazen vektor (slednje pogosto zmede programerje v Python-u). Oznaka za prazen vektor je logical(0), integer(0), numeric(0) ali charcter(0), v odvisnosti od tipa vrednosti elementov vektorja.

Nekaj primerov, kjer je vi vektor celoštevilskih vrednosti:

v = c(1.1, -2.2, 3.3, -4.4)

v[3:1] # običajno

[1]  3.3 -2.2  1.1

v[c(1, 3, 1)] # ponovitev istega elementa

[1] 1.1 3.3 1.1

v[order(v)] # urejene vrednosti elementov

[1] -4.4 -2.2  1.1  3.3

v[order(v)] = c(1.1, 2.2, 3.3, 4.4) # indeksiranem vektorju lahko dodelimo vrednosti (!)

v

[1] 3.3 2.2 4.4 1.1

v[c(-1, -3)] # negativni indeksi

[1] 2.2 1.1

# v[-1:1] # kombiniranje negativnih in pozitivnih indeksov ni dovoljeno

In še nekaj primerov

v = c(4.2, 3.3, 5.4, 2.1)
v

[1] 4.2 3.3 5.4 2.1

v[c(TRUE, TRUE, FALSE, FALSE)] # logične vrednosti

[1] 4.2 3.3

v[v > 3] # indeksiranje z logičnim pogojem

[1] 4.2 3.3 5.4

v > 3 # kar je pravzaprav indeksiranje z logičnimi vrednostmi

[1]  TRUE  TRUE  TRUE FALSE

v[v > 3] = 3 # dodeljevanje (!)
v

[1] 3.0 3.0 3.0 2.1

v = v[v != 3] # izbira elementov, ki izpolnjujejo pogoj
v

[1] 2.1

Matrike najbolj pogosto indeksiramo z dvema vektorjema:

M = 1:20
dim(M) = c(4, 5)
colnames(M) = toupper(letters[1:ncol(M)])
M

     A B  C  D  E
[1,] 1 5  9 13 17
[2,] 2 6 10 14 18
[3,] 3 7 11 15 19
[4,] 4 8 12 16 20

M[1:2, ] # izbira vrstic, vsi stolpci

     A B  C  D  E
[1,] 1 5  9 13 17
[2,] 2 6 10 14 18

M[1, ] # ena vrstica, R jo samodejno spremeni v vektor

 A  B  C  D  E 
 1  5  9 13 17 

M[1, , drop = FALSE] # eno-vrstična matrika, R-ju preprečimo samodejno pretvorbo v vektor

     A B C  D  E
[1,] 1 5 9 13 17

M[, c(2,1)] # izbira stolpcev, vse vrstice - bodite pozorni na vrstni red

     B A
[1,] 5 1
[2,] 6 2
[3,] 7 3
[4,] 8 4

M[1, 1] # izbira enega elementa matrike, rezultat je skalar

A 
1 

M[1, 1, drop = FALSE] # rezultat je matrika dimenzij 1x1

     A
[1,] 1

Lahko pa jih indeksiramo tudi z navadnim vektorjem ali matriko, v obeh primerih je rezultat vektor:

M

     A B  C  D  E
[1,] 1 5  9 13 17
[2,] 2 6 10 14 18
[3,] 3 7 11 15 19
[4,] 4 8 12 16 20

M[c(4, 15)]

[1]  4 15

M[c(-4, -15)]

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

MI = matrix(
  c(
    1, 1,
    3, 1,
    2, 5
  ),
  ncol = 2, byrow = TRUE
)
dim(MI) = c(3, 2)
M[MI]

[1]  1  3 18

Računanje z vektorji in recikliranje elementov vektorja

Vektorji so pravzaprav osnovni tip podatkov v R-ju, tako osnovni, da skalarje obravnavamo kot posebna vrsta vektorjev z enim elementom. Zato nad vektorji lahko izvajamo operacije z osnovnimi aritmetičnimi operatorji in matematičnimi funkcijami. V nadaljevanju si bomo ogledali posebnosti uporabe operatorjev in funkcij nad vektorji.

Osnovni operatorji

Za izvajanje osnovnih aritmetičnih operacij so v R-ju na voljo aritmetični operatorji popisani v spodnji tabeli. V vseh primerih se oznake vektorjev začnejo z v, oznake skalarjev s s, oznake matrik z m in oznake logičnih vrednosti z l.

Operator (oznaka)	Pomen (ime)	Primer(i) uporabe
+	seštevanje	s1 + s2, v1 + v2, v + s
-	odštevanje	v1 - v2, v - s
*	množenje	v1 * v2, v * s
/	deljenje	v1 * v2, v / s
%/%	celoštevilsko deljenje	v1 %/% v2, v1 %/% s
%%	ostanek pri celoštevilskem deljenju	v1 %% v2, v1 %% s, s %% v1
^	potenca	v1 ^ v2, v ^ s, s ^ v
%*%	matrično množenje	m1 %*% m2

Kot vidimo iz primerov v zgornji tabeli, operanda podanega operatorja sta lahko vektorja, skalarja ali pa kombinacija vektorja in skalarja. Preden pojasnimo pravila za izvajanje operatorjev nad vektorji, si bomo ogledali še tabelo operatorjev primerjave (prvih šest vrstic) in logičnih operatorjev (zadnjih pet vrstic).

Operator (oznaka)	Pomen (ime)	Primer(i) uporabe
==	enaki vrednosti	s1 == s2, v1 == s, v1 == v2
!=	različni vrednosti	s1 != s2, v1 != s, v1 != v2
<	vrednost manjša	s1 < s2, v1 < s, v1 < v2
<=	vrednost manjša ali enaka	s1 <= s2, v1 <= s, v1 <= v2
>	vrednost večja	s1 > s2, v1 > s, v1 > v2
>=	vrednost večja ali enaka	s1 >= s2, v1 >= s, v1 >= v2
&	konjunkcija, logični in	s1 & s2, v1 & v2, v & s
|	disjunkcija, logični ali	s1 | s2, v1 | v2, v | s
!	negacija, logični ne	! s, ! v
&&	konjunkcija dveh logičnih vrednosti	l1 && l2
||	disjunkcija dveh logičnih vrednosti	l1 || l2

Zadnja dva operatorja (&& in ||) sta posebna, ker oba obravnavata svoja operanda kot skalarni logični vrednosti in je tako rezultat operacije skalarna logična vrednost TRUE ali FALSE.

Koristen operator, ki ne sodi v zgoraj opisane kategorije, je %in%, ki ga uporabljamo v izrazih oblike s %in% v zato, da preverimo, če je skalar s element vektorja v. Izraz vrne TRUE v primeru, ko je s element vektorja v. Sicer pa vrne FALSE.

Recikliranje elementov vektorja

Kombiniranje različnih tipov operandov (t.j., vektorjev in skalarjev ali pa vektorjev različnih dolžin) ima svoje omejitve, ki jih moramo upoštevati pri pisanju pravilnih izrazov v R-ju.

Pri izvajanju operacije v1 op v2, morata vektorja v1 in v2, ki nastopata kot operanda (primerjalnega, logičnega ali aritmetičnega) operatorja op, izpolnjevati enega izmed naslednjih dveh pogojev.

1. Vektorja sta enakih dimenzij, t.j., velja dim(v1) == dim(v2). V primeru navadnih vektorjev, ki niso večdimenzionalni (matrike ali polja oziroma tenzorji), to pomeni, da sta enakih dolžin length(v1) == length(v2). Če sta matriki, to pomeni, da morata biti enakih dimenzij. Izjema pri matrikah je matrično množenje, pri katerem moramo upoštevati običajno omejitev da mora imeti prva matrika toliko stolpcev, kot ima druga matrika vrstic.
   
   Če je ta pogoj izpolnjen, je rezulat v izvajanja operacije enakih dimenzij kot operanda. Prvi element dobimo z uporabo operanda na prvih elementih operandov, t.j., prvi element rezultata je v[1] = v1[1] op v2[1].
   
   Ta pogoj izpolnjuje tudi običajna operacija med dvema skalarjema oblike s1 op s2, kjer sta očitno oba operanda dimenzije oziroma dolžine 1.

2. Dolžina daljšega vektorja (označimo ga z v1) je večkratnik dolžine krajšega v2, t.j., velja length(v1) == length(v2) * k, kjer je k naravno število večje od 1. V tem primeru R pred izvajanjem operacije predela krajši vektor v dalšega tako, da elemente krajšega vektorja reciklira k-krat.
   
   Poseben primer tega pogoja je operacija vektorja s skalarjem (in skalarja z vektorjem), kajti, kot smo povedali že na začetku tega razdelka, je skalar pravzaprav vektor dolžine 1. V tem primeru podano skalarno vrednost recikliramo tolikokrat, kot je dolžina daljšega operanda, torej vektorja.

Zato, da bolje razumeš recikliranje, se poigraj z naslednjimi primeri:

v = -4:4

v + TRUE # pojasni rezultat, ne pozabi na prisilno prilagajanje tipov

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

v > 0 # premisli kako R reciklira vrednosti v tem izračunu,

[1] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE

v < 1:-1 # kako v tem,

[1]  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE

v < 1:-2 # in zakaj tukaj dobimo opozorilo

Warning: longer object length is not a multiple of shorter object length

[1]  TRUE  TRUE  TRUE FALSE  TRUE FALSE FALSE FALSE FALSE

v * (-1:1)

[1]  4  0 -2  1  0  1 -2  0  4

v / (-1:1) # pojasni ta rezultat

[1]    4 -Inf   -2    1  NaN    1   -2  Inf    4

Osnovne funkcije nad skalarji in vektorji

V R-ju pogosto uporabljamo dve obliki funkcij, ki kot argument sprejmejo vektor.

1. Običajne matematične funkcije oblike \(f: \mathbb{R} \to \mathbb{R}\), kot so npr. sin, cos, log, log10 ali exp. Ko tem funkcijam podamo za argument vektor v, je rezultat vektor vrednosti funkcije na posameznih elementih vektorja v.

2. Matematične funkcije oblike \(f: \mathbb{R}^* \to \mathbb{R}\), torej funkcije, ki poljubno število numeričnih argumentov združijo v skalarno vrednost. Ko tem funkcijam podamo kot argument vektor v, je rezultat skalarna vrednost. Primeri takih funkcij so sum, mean, sd in length, ki vrnejo vsoto, povprečno vrednost, standardni odklon in število elementov vektorja.

Pogosto nam koristijo tudi dve funkciji nad nizi znakov: * nchar(x), ki kot rezultat vrne število znakov v podanem nizu znakov x. * paste(x1, x2, ..., xn), ki kot rezultat vrne en niz znakov dobljen s stikom podanih nizov znakov x1, x2, …, xn z vmesnimi presledki. Različica te funkcije paste0 opravi stik podanih nizov brez vmesnih presledkov.

In še nekaj koristnih funkcij za vektorje: * sort(v) vrne vektor z elementi vektorja v urejenimi v naraščajočem vrstnem redu. Različica klica sort(v, decreasing=TRUE) uredi elemente vektorja v padajočem vrstnem redu. * unique(v) vrne vektor elementov v brez ponavljanja, rezultat je torej vektor v katerega se vsak element pojavi le enkrat. * which(v), kjer je v vektor logičnih vrednosti, vrne celoštevilski vektor indeksov elementov v, ki imajo vrednost TRUE. Če je v poimenovan vektor, vrne vektor z imeni teh elementov.

Primeri

Poglejmo si nekaj primerov tvorjenja seznamov in operacij nad njimi.

Tvorjenje vektorjev z : in primeri operacij, ki kombinirajo vektorje in skalarje:

1:5

[1] 1 2 3 4 5

5:-5

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

2 ^ (0:5)

[1]  1  2  4  8 16 32

(0:5) ^ 2

[1]  0  1  4  9 16 25

(0:5) ^ (5:0)

[1] 0 1 8 9 4 1

x = 10
(2:(x -1))

[1] 2 3 4 5 6 7 8 9

Tvorjenje vektorjev z seq in funkcije:

seq(0, 1, 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

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

[1] 0.0 0.2 0.4 0.6 0.8 1.0

seq(0, 1, length.out=6) * seq(0, 1, length.out=3)

[1] 0.0 0.1 0.4 0.0 0.4 1.0

sin(seq(0, pi, length.out=5))

[1] 0.000000e+00 7.071068e-01 1.000000e+00 7.071068e-01 1.224647e-16

mean(0:100)

[1] 50

Ponavljanje z rep:

rep(-1:1, 3)

[1] -1  0  1 -1  0  1 -1  0  1

rep(-1:1, each=2)

[1] -1 -1  0  0  1  1

unique(rep(-1:1, 3))

[1] -1  0  1

In še naključno vzorčenje s ponavljanjem in brez:

sort(sample(-5:5, 5, replace=F))

[1] -5 -1  1  3  4

sort(sample(-5:5, 5, replace=T))

[1] 0 4 5 5 5

Posebne vrste vektorjev

Faktor (angl. factor) je vektor z elementi, ki imajo vrednosti iz vnaprej znane, relativno majhne množice možnih vrednosti. To množico določa atribut faktorja levels.

Faktorje tvorimo iz vektorjev s funkcijo factor:

x = factor(c("a", "b", "b", "a"))
x

[1] a b b a
Levels: a b

typeof(x)

[1] "integer"

attributes(x)

$levels
[1] "a" "b"

$class
[1] "factor"

Kot vidimo so faktorji pravzaprav celoštevilski vektorji. Nabor možnih vrednosti lahko nastavimo tudi naknadno, kar nam pomaga pri analizi podatkov. Tako, npr. faktorju x iz zgornje kode lahko dodamo možno vrednost "c", kar spremeni obnašanje funkcije table, ki prešteva frekvence pojavitev različnih vrednosti v faktorju (ali vektorju):

table(x)

x
a b 
2 2 

levels(x) = c(levels(x), "c")
table(x)

x
a b c 
2 2 0 

Možne vrednosti faktorjev so v splošnem neurejen. Če so možne vrednosti elementov urejene, potem je faktor urejen. Urejene faktorje tvorimo s funkcijo ordered:

ocene = ordered(
  c("dobro", "odlično", "prav dobro", "zadostno", "zadostno"),
  levels = c("zadostno", "dobro", "prav dobro", "odlično")
)

ocene

[1] dobro      odlično    prav dobro zadostno   zadostno  
Levels: zadostno < dobro < prav dobro < odlično

Bodite pozorni na zadnjo vrstico izhoda, ki z uporabo znaka < pove kakšna je urejenost možnih vrednosti elementov.

Datumski vektor je nadgradnja vektorjev numeričnih vrednosti (plavajoče vejice). Tvorimo jih lahko na več načinov. S funkcijami as.Date, če nas čas/ ura ne zanima, ali as.POSIXct, če hočemo datumu pridružiti tudi uro:

now = as.Date(Sys.Date())
now

[1] "2024-10-06"

future = as.Date(Sys.Date() + 360)
future

[1] "2025-10-01"

duration = future - now
typeof(duration)

[1] "double"

duration

Time difference of 360 days

now = as.POSIXct(Sys.time(), )

Bodite pozorni na izpis zgornjega primera Časovna razlika 360 dni: razlika dveh datumov je poseben tip datumskega vektorja, ki ustreza časovnemu intervalu. Tvorimo ga lahko tudi sami s funkcijo as.difftime in določamo enote:

duration = as.difftime(1, units="weeks")
now + duration

[1] "2024-10-13 17:35:17 CEST"

---

Seznami (angl. lists)

Za razliko od vektorjev, seznami v R-ju lahko vsebujejo elemente, ki imajo vrednosti različnih tipov. Zato rečemo, da so seznami posplošitev vektorjev in jih imenujemo tudi splošni (generični) vektorji (angl. generic vectors). Pozor: Seznami v Python-u so pravzaprav podobni vektorjem (in ne seznamom) v R-ju.

Sezname lahko tvorimo s funkcijo list:

l1 = list(
  1:3,
  "a",
  c(TRUE, FALSE, TRUE),
  c(2.3, 5.9)
)

l1

[[1]]
[1] 1 2 3

[[2]]
[1] "a"

[[3]]
[1]  TRUE FALSE  TRUE

[[4]]
[1] 2.3 5.9

typeof(l1)

[1] "list"

length(l1)

[1] 4

Bodimo pozorni na dejstvo, ki ga kaže zadnji primer, da ima seznam štiri elemente. Vektorji (in ne njihovi posamezni elementi) so elementi seznama. Kot bomo videli pozneje so lahko tudi seznami elementi seznama.

Tako kot vektorji, so lahko tudi seznami poimenovani:

oseba = list(
  ime = "Aleksandra",
  spol = "ž",
  starost = "21"
)
oseba

$ime
[1] "Aleksandra"

$spol
[1] "ž"

$starost
[1] "21"

Sezname lahko gnezdimo, kar pomeni, da je lahko seznam element seznama. Tukaj je primer nenavadnega seznama z enim elementom:

l2 = list(list(list(1))) # res čuden seznam
l2

[[1]]
[[1]][[1]]
[[1]][[1]][[1]]
[1] 1

Različne sezname lahko kombiniramo/ sestavljamo s funkcijo c ali list:

l3 = list(list(1, 2), c(3, 4))
l3

[[1]]
[[1]][[1]]
[1] 1

[[1]][[2]]
[1] 2


[[2]]
[1] 3 4

l4 = c(list(1, 2), c(3, 4))
l4

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] 4

V zgornjih primerih bodite pozorni na razliko med seznamoma l3 in l4. Pozorno ju primerjajte, poglejte kakšna je dolžina vsakega in pojasnite zakaj pride do te razlike. Pri katerem opazujemo gnezdenje seznamov?

Če si želimo vektor pretvoriti v seznam, uporabimo funkcijo as.list. Rezultat funkcije je seznam, ki ima enako število elementov kot vektor in vsak element vektorja postane element seznama. Poglejmo še en primer, ki ponazori razliko med funkcijama as.list in list:

l5 = as.list(-2:2)
l5

[[1]]
[1] -2

[[2]]
[1] -1

[[3]]
[1] 0

[[4]]
[1] 1

[[5]]
[1] 2

l6 = list(-2:2)
l6

[[1]]
[1] -2 -1  0  1  2

Za pretvorbo seznama v vektor uporabljamo funkcijo unlist. Pri tem moramo biti pozorni na to, da morajo biti vsi elementi vektorja istega tipa. Če so elementi seznama različnih tipov, bo R med izračunom rezultata funkcije unlist opravil prisilno pretvorbo tipov. Poglejmo primere:

unlist(l1)

[1] "1"     "2"     "3"     "a"     "TRUE"  "FALSE" "TRUE"  "2.3"   "5.9"  

unlist(l2)

[1] 1

unlist(l3)

[1] 1 2 3 4

unlist(l4)

[1] 1 2 3 4

unlist(l5)

[1] -2 -1  0  1  2

unlist(l6)

[1] -2 -1  0  1  2

Pojasni zakaj sta rezultata l3 in l4 (ter l5 in l6) enaka.

Indeksiranje seznamov

Ko indeksiramo seznam s tako, kot indeksiramo vektorje, torej indeks postavimo v enojne oklepaje, na primer s[1] ali s[2:3], je rezultat indeksiranja vedno seznam, četudi seznam z enim elementom. Če želimo z indeksiranjem seznama dobiti njegove posamezne elemente, moramo uporabljati dvojne oglate oklepaje. Prvi element seznama torej dobimo z izrazom s[[1]].

Poglejmo nekaj primerov:

l1[2:3] # seznam z dvema elementoma

[[1]]
[1] "a"

[[2]]
[1]  TRUE FALSE  TRUE

l1[-4] # seznam s tremi elementi

[[1]]
[1] 1 2 3

[[2]]
[1] "a"

[[3]]
[1]  TRUE FALSE  TRUE

l1[1] # seznam z enim elementom

[[1]]
[1] 1 2 3

typeof(l1[1])

[1] "list"

l1[[1]] # prvi element seznama

[1] 1 2 3

typeof(l1[[1]])

[1] "integer"

Opomba: dvojne oglate oklepaje lahko uporabljamo tudi za dostop do posameznih elementov vektorja. Veliko programerjev v R-ju se poslužuje dvojnih oklepajev pri naslavljanju posameznih elementov vektorja (in seveda seznama) zato, da je koda bolj pregledna. Z dvojnimi oklepaji namreč poudarimo, da želimo z indeksiranjem nasloviti točno en element vektorja. Ko pa uporabljamo indeksiranje za dostop do večjega (ali poljubnega) števila elementov, potem moramo uporabljati enojne oklepaje.

V poimenovanih seznamih lahko posamezne elemente naslovimo na več načinov:

oseba[[1]]

[1] "Aleksandra"

oseba[["ime"]]

[1] "Aleksandra"

oseba$ime

[1] "Aleksandra"

Prvi način z uporabo znaka $ je najbolj običajen in pogosto uporabljen.

---

Naloge

Premisleki brez poganjanja R

1. Naštej po par primerov izrazov z numeričnimi vrednostmi Inf, -Inf in NaN.
2. Kakšen je tip elementov vektorja c(1:5, FALSE)?
3. Kaj je rezultat klicev length(c(1:5, 5:1)) in lenght("abc")?
4. Premisli kako dolga bosta vektorja 1:5 + 1 in 1:(5 + 1).
5. Kaj izračuna izraz sum(v == 3) za podan vektor v? Kako je vrednost tega izraza povezana z vrednostjo izraza which(v == 3)?
6. Seznam x = list(a=c(1,1), b=2, c=list(c(3,3,3),c(4))). Kakšne so vrednosti izrazov x[1], x[[2]] in x[[3]][1]? Naštej čim več načinov za pridobivanje vrednosti drugega elementa seznama x.

Programerske naloge

1. Denimo, da smo Alešu, Barbari, Cirilu in Darji izmerili višine v centimetrih (180, 165, 160, 193) in teže v kilogramih (87, 58, 65, 100). Naredi dva vektorja v in t z izmerjenimi podatki. Indeks telesne mase (ITM) izračunamo po formuli \[ \text{ITM} = \frac{\text{teža v kilogramih}}{(\text{višina v metrih})^2}. \] Izračunaj poimenovan vektor vrednosti ITM za štiri osebe, kjer so imena elementov dejanska imena oseb (Aleš, Barbara, Ciril in Darja). Nato izračunaj vektor naravnih logaritmov vrednosti ITM. Na koncu izpiši vektor imen oseb, ki imajo ITM večji od 25, ter izračunaj njihov povprečni ITM.

2. Sestavi vektorje z naslednjimi elementi:

   1. \(3^1/1, 3^2/2, \ldots, 3^{50}/50\);
   2. “A1”, “A2”, \(\ldots\), “A50”;
   3. \(e^x \sin x\) izračunanimi v točkah \(x = 3, 3.1, 3.2, \ldots, 6\).
      
      

3. Podano je naravno število x > 2. Zapiši izraz v R-ju, katerega rezultat je TRUE, če je x praštevilo in FALSE sicer. Namig: izraz gradi postopoma. Najprej izračunaj vektor ostankov deljenja x s vsemi števili od 2 do x - 1. Nato preveri, če je 0 element tega seznama.

4. Izračunaj dva vektorja x in y dolžine 250 tako, da s ponavljanjem naključno izbiraš cela števila iz intervala \([0, 999]\). Označimo z \(x_1, x_2, \ldots, x_{250}\) in \(y_1, y_2, \ldots, y_{250}\) elemente seznamov x in y. Izračunaj:

   1. Vektor z elementi \(y_2 - x_1, y_3 - x_2, \ldots, y_{250} - x_{249}\).
   2. Vsoto \(\sum_{i=1}^{249} e^{- x_{i+1}} / (x_i + 10)\).
      
      

5. Sestavi vektor tipa faktor z naborom možnih vrednosti A, B in C. Vektor naj ima naključno izbranih 15 elementov, po natanko pet (5) iz vsake kategorije.

6. Na FMF pogosto ocenjujemo dosežke študentov na izpit z odstotnimi točkami: študentka lahko doseže od 0 do 100 odstotnih točk (vključno). Dosežek v odstotnih točkah (%) nato prevedemo v oceno s predpisom iz spodnje tabele.

   dosežek v %	ocena
   večji od 90	odlično (10)
   večji od 80 in največ 90	prav dobro (9)
   večji od 70 in največ 80	prav dobro (8)
   večji od 60 in največ 70	dobro (7)
   večji od 50 in največ 60	zadostno (6)
   največ 50	nezadostno (5)

   1. Sestavi vektor ot z naključnimi dosežki dvajsetih študentov;
   2. Pretvori dosežke iz vektorja ot v vektor o tipa urejen faktor, katerih elementi so ocene študentov izračunane po zgornjem predpisu.
      
      

7. V programu za urejanje preglednic Excel (in podobno v programih Google Sheets ali Numbers) so stolpci poimenovani z velikimi črkami angleške abecede (od A do Z), nato sledijo stolpci poimenovani s dvema črkama (od AA, prek AB, AC, in tako naprej, do ZY in ZZ), nato še tisti s tremi črkami (od AAA do ZZZ).
   
   Zadnji stolpec v preglednici je poimenovan XFD. Napiši program v R-ju, ki izračuna koliko stolpcev ima preglednica v programu Excel.
   
   Namig: uporabiš lahko LETTERS, t.j., vektor velikih črk v angleški abecedi, ter klice funkcij sort in outer (pomagaj si z ?outer) v kombinaciji s funkcijo paste0 za izračun vektorja z imeni stolpcev. Nato s klicem funkcije which ugotovite indeks stolpca XFD v tem vektorju.

8. Vse vektorje in skalarje, izračunane v prvi nalogi zgoraj (nalogi o indeksu telesne mase), sestavi v seznam resitev s polji imena, visine, ITM, logITM, ITM.v.25, imena.ITM.v.25 in ITM.v.25.povprecje.

---

Prvo različico tega zvezka sem oktobra 2021 pripravil Ljupčo Todorovski v jeziku R Markdown. Ideje za primere sem si v veliki meri izposojal iz učbenika (Wickham 2019), vse morebitne napake v primerih so izključno moje. Zvezek sem nazadnje spreminjal oktobra 2024.

V zvezkih z zapiski s predavanj pri tem predmetu je . oznaka za decimalno vejico in , ločilo med tisočicami, kar v slovenščini nenavadno (ali pa kar narobe). Tako je 3/2 = 1.5 (in ne 1,5) in je 1e6 = 1000000 = 1,000,000 (in ne 1.000.000).