Hlavní navigace

Programovací jazyk R: vektory ve funkci základního datového typu jazyka

 Autor: R Core Team
Ve druhém článku o jazyku R se budeme zabývat základním (a nejpoužívanějším) datovým typem tohoto jazyka. Jedná se o vektory, což jsou homogenní datové struktury, pro které je definováno mnoho funkcí i operátorů.
Pavel Tišnovský 3. 9. 2020
Doba čtení: 20 minut

Sdílet

Obsah

1. Programovací jazyk R (vektory ve funkci základního datového typu jazyka)

2. Konstrukce vektorů

3. Konverze hodnot při konstrukci vektorů

4. Funkce seq

5. Funkce rep

6. Přístup k prvkům vektoru

7. Výběr většího množství prvků

8. Operace prováděné nad vektory

9. Porovnávání vektorů prvek po prvku

10. Funkce all

11. Funkce which

12. Součet vektorů prvek po prvku, automatické prodloužení vektorů

13. Ostatní operace prováděné nad prvky vektorů

14. Dělení nulou

15. Dělení se zbytkem

16. Logické operace nad prvky vektorů

17. Konsolidované logické operace

18. Obsah následujícího článku

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Programovací jazyk R (vektory ve funkci základního datového typu jazyka)

Programovací jazyk R podporuje několik datových typů (seznam, pole, matice, tabulka, uzávěr, …), ovšem existuje mezi nimi jeden typ využívaný v prakticky všech skriptech a ve většině funkcí. Jedná se o vektory (vector), jejichž prvky mohou obsahovat logické hodnoty, celá čísla, čísla typu double, komplexní čísla, znaky či řetězce atd. Takovým vektorům se někdy říká atomické (což ovšem může být matoucí, protože pojem atom je v oblasti programovacích jazyků použit pro několik rozdílných konceptů). Zajímavé je, že když použijete číslo, popř. nějaká funkce číslo vrací, jedná sice o skalární hodnotu, ale můžeme s ní pracovat jako s plnohodnotným vektorem. Jednotlivé typy vektorů jsou shrnuty v následující tabulce:

# Typ Stručný popis
1 integer celá čísla (kladná i záporná)
2 double čísla s plovoucí řádovou čárkou
3 complex komplexní čísla
4 character znaky tvořící řetězec (vektor tedy obsahuje jeden nebo více řetězců)
5 logical pravdivostní hodnoty TRUE a FALSE
6 raw bajty (typicky znaky převedené na bajty)
Poznámka: vektory jsou v jazyku R homogenními datovými strukturami, takže všechny jejich prvky mají stejný typ. Pokud budete potřebovat pracovat s heterogenními strukturami, lze namísto vektorů použít seznamy, které si popíšeme příště. Pro jejich konstrukci se používá funkce list.

2. Konstrukce vektorů

Se základními konstruktory vektorů jsme se již ve stručnosti seznámili minule, takže si nyní pouze připomeňme, že existuje hned několik způsobů konstrukce nového vektoru. V případě, že má vektor obsahovat jen jedinou hodnotu, je vytvoření takového vektoru jednoduché a přímočaré, protože vlastní zápis hodnoty (typicky čísla) již představuje skalární hodnotu, která se však chová jako vektor (má délku rovnou jedné, může se používat v operacích, kde se očekávají vektory atd.):

> 42
 
[1] 42

O tom, jakého typu je takový skalár nebo vektor, se můžeme přesvědčit zavoláním funkce class:

> class(42)
 
[1] "numeric"

Vektor s obecnými prvky se vytvoří konstruktorem nazvaným c, což je funkce, které se předají hodnoty jednotlivých prvků:

> a <- c(1,2,3,4)
 
> class(a)
 
[1] "numeric"

Prvky samozřejmě nemusí být pouze celými čísly, ale například i hodnotami s plovoucí řádovou čárkou:

> b <- c(1.2, 2.3, 3.4)
 
> class(b)
 
[1] "numeric"

Nakonec si vyzkoušíme vytvoření vektoru obsahujícího pravdivostní hodnoty TRUE a FALSE:

> l <- c(TRUE, FALSE, TRUE)
 
> class(l)
 
[1] "logical"

3. Konverze hodnot při konstrukci vektorů

V úvodní kapitole jsme si řekli, že vektory jsou homogenními datovými strukturami, tedy že všechny jejich prvky jsou stejného typu (což v důsledku vede k mnohem rychlejší práci s nimi – ostatně stejný způsob se používá i v NumPy a podobných balíčcích). Co se ovšem stane ve chvíli, pokud funkci c (konstruktoru) předáme prvky různého typu? Můžeme si to snadno otestovat přímo v REPLu:

> x <- c(1, FALSE, TRUE, 42)

Pokud vypíšeme typ vektoru, zjistíme, že obsahuje numerické hodnoty:

> class(x)
 
[1] "numeric"

Je tomu tak z toho důvodu, že se interpret programovacího jazyka R pokusil o převod pravdivostních hodnot na celočíselné hodnoty 0 a 1 (což je ovšem v mnoha případech velmi výhodné chování). Výsledkem je tedy opět homogenní datová struktura:

> x
[1]  1  0  1 42
 
> l

V dalším demonstračním příkladu nejdříve vytvoříme vektor obsahující řetězce (pro jednoduchost jednopísmenné řetězce):

> y <- c("a", "b", "c")
 
> y
[1] "a" "b" "c"

Přesvědčíme se o typu vektoru:

> class(y)
 
[1] "character"

Nyní se pokusíme vytvořit vektor s prvky typu řetězec a současně celé číslo:

> z <- c("a", 42, "c")

V tomto případě se jazyk R pokusí o převod celých čísel na řetězec, což je podporovaná operace:

> class(z)
 
[1] "character"

Výsledkem je vektor obsahující trojici řetězců (tedy opět homogenní datová struktura):

> z
 
[1] "a"  "42" "c"

V případě typových konverzí se většinou provádí přímé konverze z jednoho typu přímo na typ požadovaný. To například znamená, že pravdivostní hodnota TRUE je přímo převedena na řetězec a nikoli napřed na celé číslo (1):

> c(TRUE, 42, "foobar")
 
[1] "TRUE"   "42"     "foobar"

4. Funkce seq

Minule jsme si taktéž řekli, že zápisem a:b je možné zkonstruovat vektor s prvky, které začínají hodnotou a a končí hodnotou b (a to včetně obou krajních hodnot). Následuje příklad použití takto pojaté konstrukce vektoru:

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

Počítat lze i zpět, tj. první hodnota může být větší než hodnota druhá:

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

Pro složitější případy (neceločíselné kroky či meze atd.) se používá funkce seq, což je zkratka od slova sequence. Vytvoření vektoru o deseti prvcích může vypadat následovně:

> seq(1,10)
 
 [1]  1  2  3  4  5  6  7  8  9 10

Pokud je první mezní hodnota větší než druhá, bude krok automaticky nastaven na –1:

> seq(10,1)
 
 [1] 10  9  8  7  6  5  4  3  2  1

Specifikovat je možné i krok (který je jinak explicitně nastavený na 1 nebo –1):

> seq(1,5,by=0.5)
 
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0

V některých případech je výhodnější specifikovat délku vektoru (počet prvků) a hodnoty prvního a posledního prvku:

> seq(length=10, from=0, to=1)
 
 [1] 0.0000000 0.1111111 0.2222222 0.3333333 0.4444444 0.5555556 0.6666667
 [8] 0.7777778 0.8888889 1.0000000
 
 
> seq(length=11, from=0, to=1)
 
 [1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
Poznámka: podrobnější popis této funkce naleznete na stránce https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/seq.

5. Funkce rep

Další funkcí, kterou je možné použít pro vytvoření nového vektoru, je funkce nazvaná rep, což je zkratka slova repeat. Tato funkce vytváří vektor opakováním prvku či prvků. Nejjednodušší je použití této funkce v případě, kdy je vstupem vektor s jediným prvkem:

> rep(42, 10)
 
 [1] 42 42 42 42 42 42 42 42 42 42

Opakovat ovšem můžeme i delší vektor, například dvouprvkový vektor:

> a <- c(1,2)
 
> rep(a, times=5)
 
 [1] 1 2 1 2 1 2 1 2 1 2

Další varianta vytváří odlišný vektor, protože napřed opakuje první prvek pětkrát a následně druhý prvek (taktéž pětkrát):

> a <- c(1,2)
 
> rep(a, each=5)
 
 [1] 1 1 1 1 1 2 2 2 2 2

Nic nám samozřejmě nebrání v tom opakovat vektor s logickými hodnotami a vytvořit tak vektor nový:

> l <- c(TRUE, FALSE)
 
> u <- rep(l, 10)
 
> u
 
 [1]  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE
[13]  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE

Existuje ještě jedna zajímavá varianta, kterou je možné použít ve chvíli, kdy potřebujeme opakovat prvky nějakého vstupního vektoru, ovšem délka výsledného vektoru není celočíselným násobkem délky vektoru vstupního. V tomto případě se použije parametr nazvaný length.out:

> a <- c(1, 2, 3)
 
> rep(a, length.out=10)
 
 [1] 1 2 3 1 2 3 1 2 3 1
 
 
> rep(a, length.out=20)
 [1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2
Poznámka: podrobnější popis této funkce naleznete na stránce https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/rep.

6. Přístup k prvkům vektoru

Pro přečtení hodnoty nějakého prvku vektoru se používá „indexovací“ operátor, který známe i z mnoha dalších programovacích jazyků. Ovšem musíme si dát pozor na to, že prvky jsou indexovány od jedničky a nikoli od nuly. První prvek vektoru má tedy index roven jedné, poslední prvek má index roven length(vector) atd.:

> a <- c("a", "b", "c", "d", "e", "f")
 
> a
[1] "a" "b" "c" "d" "e" "f"
 
> a[1]
[1] "a"
 
> a[6]
[1] "f"

Přístup k nultému prvku je možný, ovšem nevrací hodnotu prvku:

> a[0]
 
character(0)

Pokus o přístup k neexistujícímu prvku vrací hodnotu NA neboli Not Available (což je jedna ze čtyř speciálních hodnot):

> a[7]
 
[1] NA

Pokud se použije záporný index, bude vrácen původní vektor, ovšem bez prvku, který je reprezentován daným indexem (převedeným na absolutní hodnotu):

> a[-1]
 
[1] "b" "c" "d" "e" "f"
 
> a[-5]
 
[1] "a" "b" "c" "d" "f"
Poznámka: pozor – toto chování je značně odlišné od jiných programovacích jazyků, kde záporný index značí indexování od konce vektoru!

Prvky vektoru je možné měnit (mutovat) v případě, že indexovaný prvek bude na pravé straně operátoru přiřazení:

> a <- rep(42, 10)
> a
 
 [1] 42 42 42 42 42 42 42 42 42 42
 
> a[5] <- 0
> a
 
 [1] 42 42 42 42  0 42 42 42 42 42

Existuje ještě složitější kombinace, a to záporného indexu s přiřazením hodnoty do zbývajících prvků (kromě prvku NEvybraného):

> a <- rep(42, 10)
> a
 
 [1] 42 42 42 42 42 42 42 42 42 42
 
> a[-4] = rep(0, 9)
> a
 [1]  0  0  0 42  0  0  0  0  0  0

Tímto příkladem jsme změnili všechny prvky kromě prvku čtvrtého.

7. Výběr většího množství prvků

V programovacím jazyku R je možné z vektoru současně vybrat i větší počet prvků, což je velmi užitečná operace. Indexy prvků, které se mají vybrat, jsou uloženy ve druhém (výběrovém) vektoru. Ovšem následující zápis není povolen (resp. povolen je, ale ne pro jednorozměrné vektory):

> a <- c("a", "b", "c", "d", "e", "f")
 
> a
[1] "a" "b" "c" "d" "e" "f"
 
> a[2,3,4]
Error in a[2, 3, 4] : incorrect number of dimensions

Namísto toho je nutné do operátoru indexování předat skutečný vektor. Vybereme tedy druhý, třetí a čtvrtý prvek:

> a[c(2,3,4)]
 
[1] "b" "c" "d"

Výběr prvků v odlišném pořadí je pochopitelně taktéž umožněn:

> a[c(4,2,3)]
 
[1] "d" "b" "c"

Pomocí zápisu 2:4 je taktéž vytvořen vektor, takže následující příkaz je legální a plně funkční:

> a[2:4]
 
[1] "b" "c" "d"

Výběr kopie původního vektoru:

> a[1:length(a)]
 
[1] "a" "b" "c" "d" "e" "f"

Pokud použijeme index prvku, který neexistuje, vrátí se NA:

> a[1:10]
 
[1] "a" "b" "c" "d" "e" "f" NA  NA  NA  NA

Operace s postupným filtrováním prvků z výsledků (opakuje se indexování se záporným indexem):

> a <- c("a", "b", "c", "d", "e", "f")
 
> a
[1] "a" "b" "c" "d" "e" "f"
 
> a[c(-2, -3, -4)]
[1] "a" "e" "f"
 
> a[c(-2)]
[1] "a" "c" "d" "e" "f"
 
> a[c(-2, -3)]
[1] "a" "d" "e" "f"
 
> a[c(-2, -3, -4)]
[1] "a" "e" "f"

8. Operace prováděné nad vektory

Nad vektory, resp. přesněji řečeno nad prvky, z nichž se vektory skládají, lze provádět relativně velké množství operací, které si postupně popíšeme v navazujícím textu. Většina operací je definována nad vektory obsahujícími čísla, jen některé operace pracují s vektory řetězců nebo logických hodnot.

9. Porovnávání vektorů prvek po prvku

Dvojici vektorů je možné porovnat s využitím jednoho ze šesti relačních operátorů. Výsledkem bude nový vektor obsahující pravdivostní hodnoty TRUE a FALSE. Délka výsledného vektoru bude rovna délce většího ze vstupních vektorů, protože jazyk R dokáže kratší vektor „natáhnout“ (zrecyklovat) tak, aby jeho délka odpovídala druhému vektoru (recyklace je založena na opakování prvků vektoru, takže pokud nejsou délky soudělné, vypíše se varování):

> a <- 1:10
 
> a < 5
 [1]  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE
Poznámka: v tomto případě se jednoprvkový vektor 5 natáhl na délku deseti prvků se stejnou hodnotou.

Dtto, ale výběr těch prvků, které jsou větší než 5:

> a > 5
 
 [1] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

Použití relačních operátorů rovnosti a nerovnosti:

> a != 5
 
 [1]  TRUE  TRUE  TRUE  TRUE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE
 
 
> a == 5
 
 [1] FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE
Poznámka: pokud potřebujete zjistit rovnost celých vektorů, použije se funkce identical:
> identical(a, b)
 
[1] FALSE
 
 
> identical(a, a)
 
[1] TRUE

10. Funkce all

V některých případech sice potřebujeme porovnat prvky dvou vektorů (přesněji řečeno vždy dvojice prvků se stejným indexem), ovšem jako výsledek vyžadujeme hodnotu TRUE, pokud podmínka platí pro všechny dvojice a FALSE v případě, že alespoň pro jednu dvojici podmínka neplatí. V takových případech je vhodné použít funkci nazvanou all. Ukažme si nyní způsob jejího použití. Nejdříve vytvoříme zdrojové vektory:

> a <- 1:5
> b <- c(2, 2, 3, 5, 5)

A poté zjistíme, zda nějaká podmínka (je větší, je menší nebo rovno atd.) platí pro všechny dvojice, tj. pro všechny prvky se shodným indexem:

> all(a < b)
[1] FALSE
 
> all(a <= b)
[1] TRUE
 
> all(a == b)
[1] FALSE
 
> all(a != b)
[1] FALSE

Stejná operace, ovšem druhá skalární hodnota je převedena na vektor:

> a <- 1:5
 
> all(a<10)
[1] TRUE
 
> all(a<5)
[1] FALSE
 
> all(a!=0)
[1] TRUE
Poznámka: povšimněte si, že ve skutečnosti tato funkce zpracovává vektor obsahující logické hodnoty – samotné podmínky jsou vyhodnoceny dříve.

11. Funkce which

Existuje ještě funkce nazvaná which, která vrací indexy těch dvojic prvků, které splňují určitou podmínku. Indexy se pochopitelně vrací ve tvaru vektoru:

> a <- 1:5
 
> b <- c(2, 2, 3, 5, 5)
 
> which(a == b)
[1] 2 3 5

Zjištění dalších vlastností vektorů:

> which(a != b)
[1] 1 4
 
> which(a < b)
[1] 1 4
 
> which(a <= b)
[1] 1 2 3 4 5

Popř.:

> which(a < 5)
[1] 1 2 3 4
 
> which(a == 0)
integer(0)
 
> which(a > 1)
[1] 2 3 4 5
Poznámka: opět si povšimněte, že ve skutečnosti tato funkce zpracovává vektor obsahující logické hodnoty – samotné podmínky jsou vyhodnoceny dříve.

12. Součet vektorů prvek po prvku, automatické prodloužení vektorů

Prvky vektorů je možné sčítat, a to podobně, jako byly porovnávány – sečtou se vždy prvky s odpovídajícími indexy. A opět platí, že kratší vektor je dorovnán na délku vektoru delšího (pokud je to nutné). Tato operace je snadno pochopitelná, takže jen krátce:

> a <- 1:6
> b <- c(2, 2, 3, 3, 5, 5)
> c <- c(10, 20)
 
 
> a
[1] 1 2 3 4 5 6
 
> b
[1] 2 2 3 3 5 5
 
> c
[1] 10 20
 
 
> a + b
[1]  3  4  6  7 10 11
 
> a + c
[1] 11 22 13 24 15 26
 
> a + 10
[1] 11 12 13 14 15 16

13. Ostatní operace prováděné nad prvky vektorů

V předchozí kapitole jsme si ukázali použití operátoru + na dvojic vektorů. Naprosto stejným způsobem lze pochopitelně použít i operátory – (rozdíl), * (součin) a / (podíl). Příslušné demonstrační příklady naleznete v repositáři; v článku si je uvádět nebudeme, protože význam těchto operací (aplikovaných na skalární hodnoty) je pravděpodobně zřejmý. Pouze pro zajímavost si ukažme výpočet převrácené hodnoty komplexních čísel:

> a <- c(1+1i, 1+0i, 0+1i, 2+2i)
 
> 1/a
[1] 0.50-0.50i 1.00+0.00i 0.00-1.00i 0.25-0.25i

14. Dělení nulou

Zastavme se na chvíli u dělení nulou. V programovacím jazyku R se jedná o plně podporovanou operaci, která může vrátit kladné nekonečno, záporné nekonečno nebo speciální hodnotu NaN (Not a Number), a to i pro celočíselné hodnoty (některé jiné jazyky naproti tomu vyhodí výjimku):

> 1/0
[1] Inf
 
> -1/0
[1] -Inf
 
> 0/0
[1] NaN

Totéž platí i při dělení prvků vektorů, kdy prvky dělitele obsahují nuly:

> a <- 1:6
> b <- c(0, 0, 0, 0, 0, 0)
> c <- c(0, 0)
 
> a
[1] 1 2 3 4 5 6
 
> b
[1] 0 0 0 0 0 0
 
> c
[1] 0 0
 
 
> a/b
[1] Inf Inf Inf Inf Inf Inf
 
> a/c
[1] Inf Inf Inf Inf Inf Inf
 
> a/0
[1] Inf Inf Inf Inf Inf Inf

A pro záporné prvky:

> a <- -1:-6
> b <- c(0, 0, 0, 0, 0, 0)
> c <- c(0, 0)
 
> a
[1] -1 -2 -3 -4 -5 -6
 
> b
[1] 0 0 0 0 0 0
 
> c
[1] 0 0
 
 
> a/b
[1] -Inf -Inf -Inf -Inf -Inf -Inf
 
> a/c
[1] -Inf -Inf -Inf -Inf -Inf -Inf
 
> a/0
[1] -Inf -Inf -Inf -Inf -Inf -Inf

15. Dělení se zbytkem

Operátor %% slouží pro výpočet zbytku po dělení. Tento operátor lze opět použít i tehdy, pokud jsou jeho operandy vektory. Podívejme se nyní na jednoduchý příklad:

> a <- 1:6
> b <- c(2, 2, 3, 3, 5, 5)
> c <- c(10, 20)
 
> a
[1] 1 2 3 4 5 6
 
> b
[1] 2 2 3 3 5 5
 
> c
[1] 10 20
 
 
> a %% b
[1] 1 0 0 1 0 1
 
> a %% c
[1] 1 2 3 4 5 6
 
> a %% 2
[1] 1 0 1 0 1 0

V programovacím jazyku R existuje i operátor %/%, který provádí celočíselné dělení. Výsledky mohou v tomto případě vypadat následovně:

> a <- 1:6
> b <- c(2, 2, 3, 3, 5, 5)
> c <- c(10, 20)
 
> a
[1] 1 2 3 4 5 6
 
> b
[1] 2 2 3 3 5 5
 
> c
[1] 10 20
 
 
> a %/% b
[1] 0 1 1 1 1 1
 
> a %/% c
[1] 0 0 0 0 0 0
 
> a %/% 2
[1] 0 1 1 2 2 3

16. Logické operace nad prvky vektorů

Nad prvky vektorů (typicky nad vektory obsahujícími prvky s hodnotami TRUE a FALSE) lze provádět i logické operace – logický součin, logický součet, negaci atd. Opět se podívejme na jednoduché příklady. Nejdříve vytvoříme dvojici vektorů obsahujících numerické hodnoty:

> a <- 1:6
 
> b <- 6:1 - 1
 
 
> a
[1] 1 2 3 4 5 6
 
> b
[1] 5 4 3 2 1 0

Dále z těchto dvou vektorů vytvoříme další dva vektory, které budou tentokrát obsahovat pouze logické hodnoty:

> c <- a < b
 
> d <- a <= b
 
 
> c
[1]  TRUE  TRUE FALSE FALSE FALSE FALSE
 
> d
[1]  TRUE  TRUE  TRUE FALSE FALSE FALSE
 

Nyní je již možné na dvojici odpovídajících prvků vektorů c a d aplikovat vybrané logické operace:

> c & d
[1]  TRUE  TRUE FALSE FALSE FALSE FALSE
 
> c | d
[1]  TRUE  TRUE  TRUE FALSE FALSE FALSE
 
> !c
[1] FALSE FALSE  TRUE  TRUE  TRUE  TRUE
 
> !d
[1] FALSE FALSE FALSE  TRUE  TRUE  TRUE

Teoreticky je možné použít i skalární hodnoty TRUE a FALSE (z těch se opakováním vytvoří vektory potřebné délky), ovšem v praxi se pravděpodobně s tímto typem „maskování“ příliš často nesetkáme:

> c & TRUE
[1]  TRUE  TRUE FALSE FALSE FALSE FALSE
 
> c & FALSE
[1] FALSE FALSE FALSE FALSE FALSE FALSE
 
> c | TRUE
[1] TRUE TRUE TRUE TRUE TRUE TRUE
Poznámka: jazyk R neobsahuje přímo operátor, který by odpovídal operaci xor. Namísto toho je nutné použít stejně pojmenovanou funkci:
> xor(c, d)
 
[1] FALSE FALSE  TRUE FALSE FALSE FALSE

17. Konsolidované logické operace

V některých algoritmech je potřebné získat jedinou pravdivostní hodnotu TRUE či FALSE, která je výsledkem postupné aplikace logické operace na odpovídající prvky vektoru (s tím, že pokud je již výsledek známý, je zbytek výpočtu ukončen) – takové výsledky se například mohou použít v podmínce if. Jedná se o operátory zapisované formou && a ||. Ty nejdříve provedou naznačenou operaci s prvními prvky obou vstupních vektorů a pokud je z tohoto mezivýsledku již zřejmý celkový výsledek (FALSE u logického součinu, TRUE u logického součtu), je výpočet ukončen. Pokud celkový výsledek známý není, pokračuje se s druhými prvky vektorů, se třetími atd.

Použijeme stejné vstupní vektory, jako tomu bylo v předchozí kapitole:

> a <- 1:6
 
> b <- 6:1 - 1
 
 
> a
[1] 1 2 3 4 5 6
 
> b
[1] 5 4 3 2 1 0

Vytvoříme z nich vektory obsahující logické hodnoty:

> c <- a < b
 
> d <- a <= b
 
 
> c
[1]  TRUE  TRUE FALSE FALSE FALSE FALSE
 
> d
[1]  TRUE  TRUE  TRUE FALSE FALSE FALSE
 

Nyní konečně můžeme použít zde popisované operátory pro získání jediné skalární hodnoty:

> c && d
[1] TRUE
 
> c || d
[1] TRUE

18. Obsah následujícího článku

Vektory sice tvoří primární datovou strukturu používanou ve výpočtech, ovšem reálná data (načítaná z externích zdrojů) většinou nemají podobu čistých vektorů – typicky se totiž jedná o tabulky, v nichž může každý sloupec nést hodnoty odlišného datového typu. A právě tabulkami, resp. přesněji řečeno způsobem práce s nimi, se budeme zabývat ve třetí části seriálu o programovacím jazyku R.

19. Repositář s demonstračními příklady

Zdrojové kódy všech dnes použitých demonstračních příkladů byly uloženy do nového Git repositáře, který je dostupný na adrese https://github.com/tisnik/r-examples V případě, že z nějakého důvodu nebudete chtít klonovat celý repositář (ten je ovšem – alespoň prozatím – velmi malý, dnes má jen jednotky kilobajtů), můžete namísto toho použít odkazy na jednotlivé demonstrační příklady, které naleznete v následující tabulce:

# Příklad Stručný popis Cesta
1 01-class-integer.R konstrukce vektoru s jediným prvkem https://github.com/tisnik/r-examples/blob/master/02-language-basic/01-class-integer.R
2 02-class-vector.R konstrukce vektoru s více prvky https://github.com/tisnik/r-examples/blob/master/02-language-basic/02-class-vector.R
3 03-from-to.R použití zápisu a:b při konstrukci vektoru https://github.com/tisnik/r-examples/blob/master/02-language-basic/03-from-to.R
4 04-seq.R konstruktor vektorů založený na funkci seq https://github.com/tisnik/r-examples/blob/master/02-language-basic/04-seq.R
5 05-rep.R konstruktor vektorů založený na funkci seq https://github.com/tisnik/r-examples/blob/master/02-language-basic/05-rep.R
6 06-item-access.R přístup k prvkům vektoru https://github.com/tisnik/r-examples/blob/master/02-language-basic/06-item-access.R
7 07-more-item-access.R výběr většího množství prvků vektoru https://github.com/tisnik/r-examples/blob/master/02-language-basic/07-more-item-access.R
8 08-item-comparison.R porovnání prvků vektorů https://github.com/tisnik/r-examples/blob/master/02-language-basic/08-item-comparison.R
9 09-all-function.R funkce all https://github.com/tisnik/r-examples/blob/master/02-language-basic/09-all-function.R
10 10-which-function.R funkce which https://github.com/tisnik/r-examples/blob/master/02-language-basic/10-which-function.R
11 11-vector-add.R součet prvků vektorů https://github.com/tisnik/r-examples/blob/master/02-language-basic/11-vector-add.R
12 12-vector-sub.R rozdíl prvků vektorů https://github.com/tisnik/r-examples/blob/master/02-language-basic/12-vector-sub.R
13 13-vector-mul.R součin prvků vektorů https://github.com/tisnik/r-examples/blob/master/02-language-basic/13-vector-mul.R
14 14-vector-div.R podíl prvků vektorů https://github.com/tisnik/r-examples/blob/master/02-language-basic/14-vector-div.R
15 15-vector-div-by-zero.R výsledek dělení nulou https://github.com/tisnik/r-examples/blob/master/02-language-basic/15-vector-div-by-zero.R
16 16-remainder.R zbytek po dělení https://github.com/tisnik/r-examples/blob/master/02-language-basic/16-remainder.R
17 17-quotient.R celočíselné dělení https://github.com/tisnik/r-examples/blob/master/02-language-basic/17-quotient.R
18 18-log-op.R logické operace https://github.com/tisnik/r-examples/blob/master/02-language-basic/18-log-op.R
19 19-consolidated-log-op.R konsolidované logické operace https://github.com/tisnik/r-examples/blob/master/02-language-basic/19-consolidated-log-op.R
20 20-in.R operátor „in“ https://github.com/tisnik/r-examples/blob/master/02-language-basic/20-in.R

20. Odkazy na Internetu

  1. The R Project for Statistical Computing
    https://www.r-project.org/
  2. An Introduction to R
    https://cran.r-project.org/doc/manuals/r-release/R-intro.pdf
  3. R (programming language)
    https://en.wikipedia.org/wi­ki/R_(programming_language)
  4. The R Programming Language
    https://www.tiobe.com/tiobe-index/r/
  5. R Markdown
    https://rmarkdown.rstudio.com/
  6. R Markdown: The Definitive Guide
    https://bookdown.org/yihui/rmarkdown/
  7. R Markdown Cheat Sheet
    https://rstudio.com/wp-content/uploads/2016/03/rmarkdown-cheatsheet-2.0.pdf
  8. Introduction to R Markdown
    https://rmarkdown.rstudio­.com/articles_intro.html
  9. R Cheat Sheets
    https://blog.sergiouri.be/2016/07/r-cheat-sheets.html
  10. R Cheat Sheet
    https://s3.amazonaws.com/quandl-static-content/Documents/Quandl±+R+Che­at+Sheet.pdf
  11. Base R Cheat Sheet
    https://rstudio.com/wp-content/uploads/2016/06/r-cheat-sheet.pdf
  12. PYPL PopularitY of Programming Language
    https://pypl.github.io/PYPL.html
  13. Tiobe index
    https://www.tiobe.com/tiobe-index/
  14. Stack Overflow: Most Loved, Dreaded & Wanted Programming Languages In 2020
    https://fossbytes.com/stack-overflow-most-loved-dreaded-wanted-programming-languages-in-2020/
  15. How to Install and Use R on Ubuntu
    https://itsfoss.com/install-r-ubuntu/
  16. R programming for beginners – Why you should use R
    https://www.youtube.com/wat­ch?v=9kYUGMg_14s
  17. GOTO 2012 • The R Language The Good The Bad & The Ugly
    https://www.youtube.com/wat­ch?v=6S9r_YbqHy8
  18. R vs Python – What should I learn in 2020? | R and Python Comparison
    https://www.youtube.com/wat­ch?v=eRP_J2yLjSU
  19. R Programming 101
    https://www.youtube.com/c/rpro­gramming101
  20. Seriál Tvorba grafů pomocí programu „R“
    https://www.root.cz/serialy/tvorba-grafu-pomoci-programu-r/
  21. Tvorba grafů pomocí programu „R“: úvod
    https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-1/
  22. Tvorba grafů pomocí programu „R“: pokročilé funkce
    https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-pokrocile-funkce/
  23. Tvorba grafů pomocí programu „R“: vkládání textu, čeština
    https://www.root.cz/clanky/grafy-pomoci-programu-r-vkladani-textu-cestina/
  24. Cesta erka: Krok nultý – instalace & nastavení – prostředí, projekty, package
    https://www.jla-data.net/r4su/r4su-environment-setup/
  25. Cesta erka: Krok první – operace a struktury – proměnné, rovnítka a dolary
    https://www.jla-data.net/r4su/r4su-data-structures/
  26. Cesta erka: Krok druhý – načtení externích dat – csvčka, excely a databáze
    https://www.jla-data.net/r4su/r4su-read-data/
  27. Cesta erka: Krok třetí – manipulace s daty – dplyr, slovesa a pajpy
    https://www.jla-data.net/r4su/r4su-manipulate-data/
  28. Cesta erka: Krok čtvrtý – podání výsledků – ggplot, geomy a estetiky
    https://www.jla-data.net/r4su/r4su-report-results/
  29. Cesta erka: Krok pátý – case study – případ piva v Praze
    https://www.jla-data.net/r4su/r4su-case-study-beer/
  30. V indexu popularity programovacích jazyků TIOBE překvapilo R, Go, Perl, Scratch a Rust
    https://www.root.cz/zpravicky/v-indexu-popularity-programovacich-jazyku-tiobe-prekvapilo-r-go-perl-scratch-a-rust/
  31. Is R Programming SURGING in Popularity in 2020?
    https://www.youtube.com/watch?v=Duwn-vImyXE
  32. Using the R programming language in Jupyter Notebook
    https://docs.anaconda.com/a­naconda/navigator/tutorial­s/r-lang/
  33. Using R on Jupyter Notebook
    https://dzone.com/articles/using-r-on-jupyternbspnotebook
  34. Graphics, ggplot2
    http://r4stats.com/examples/graphics-ggplot2/
  35. A Practice Data Set
    https://r4stats.wordpress­.com/examples/mydata/
  36. Shiny – galerie projektů
    https://shiny.rstudio.com/gallery/
  37. Seriál Programovací jazyk Julia
    https://www.root.cz/seria­ly/programovaci-jazyk-julia/
  38. Julia (front page)
    http://julialang.org/
  39. Julia – repositář na GitHubu
    https://github.com/JuliaLang/julia
  40. Julia (programming language)
    https://en.wikipedia.org/wi­ki/Julia_%28programming_lan­guage%29
  41. IJulia
    https://github.com/JuliaLan­g/IJulia.jl
  42. Introducing Julia
    https://en.wikibooks.org/wi­ki/Introducing_Julia
  43. Julia: the REPL
    https://en.wikibooks.org/wi­ki/Introducing_Julia/The_REPL
  44. Introducing Julia/Metaprogramming
    https://en.wikibooks.org/wi­ki/Introducing_Julia/Meta­programming
  45. Month of Julia
    https://github.com/DataWo­okie/MonthOfJulia
  46. Learn X in Y minutes (where X=Julia)
    https://learnxinyminutes.com/doc­s/julia/
  47. New Julia language seeks to be the C for scientists
    http://www.infoworld.com/ar­ticle/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html
  48. Julia: A Fast Dynamic Language for Technical Computing
    http://karpinski.org/publi­cations/2012/julia-a-fast-dynamic-language
  49. The LLVM Compiler Infrastructure
    http://llvm.org/
  50. Julia: benchmarks
    http://julialang.org/benchmarks/
  51. R Vector
    https://www.datamentor.io/r-programming/vector/
  52. .R File Extension
    https://fileinfo.com/extension/r
  53. Lineární regrese
    https://cs.wikipedia.org/wi­ki/Line%C3%A1rn%C3%AD_regre­se
  54. lm (funkce)
    https://www.rdocumentation­.org/packages/stats/versi­ons/3.6.2/topics/lm
  55. quit (funkce)
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/quit
  56. c (funkce)
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/c
  57. help (funkce)
    https://www.rdocumentation­.org/packages/utils/versi­ons/3.6.2/topics/help
  58. Shiny: Introduction to interactive documents
    https://shiny.rstudio.com/ar­ticles/interactive-docs.html
  59. R Release History 1997–2013
    http://timelyportfolio.git­hub.io/rCharts_timeline_r/
  60. R: atomic vectors
    https://renenyffenegger.ch/no­tes/development/languages/R/da­ta-structures/vector/
  61. 11 Best R Programming IDE and editors
    https://www.dunebook.com/best-r-programming-ide/
  62. CRAN – The Comprehensive R Archive Network
    https://cran.r-project.org/