Obsah
1. Programovací jazyk R (vektory ve funkci základního datového typu jazyka)
3. Konverze hodnot při konstrukci vektorů
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
12. Součet vektorů prvek po prvku, automatické prodloužení vektorů
13. Ostatní operace prováděné nad prvky vektorů
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
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) |
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
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
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"
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
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
> 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
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
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
> 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:
20. Odkazy na Internetu
- The R Project for Statistical Computing
https://www.r-project.org/ - An Introduction to R
https://cran.r-project.org/doc/manuals/r-release/R-intro.pdf - R (programming language)
https://en.wikipedia.org/wiki/R_(programming_language) - The R Programming Language
https://www.tiobe.com/tiobe-index/r/ - R Markdown
https://rmarkdown.rstudio.com/ - R Markdown: The Definitive Guide
https://bookdown.org/yihui/rmarkdown/ - R Markdown Cheat Sheet
https://rstudio.com/wp-content/uploads/2016/03/rmarkdown-cheatsheet-2.0.pdf - Introduction to R Markdown
https://rmarkdown.rstudio.com/articles_intro.html - R Cheat Sheets
https://blog.sergiouri.be/2016/07/r-cheat-sheets.html - R Cheat Sheet
https://s3.amazonaws.com/quandl-static-content/Documents/Quandl±+R+Cheat+Sheet.pdf - Base R Cheat Sheet
https://rstudio.com/wp-content/uploads/2016/06/r-cheat-sheet.pdf - PYPL PopularitY of Programming Language
https://pypl.github.io/PYPL.html - Tiobe index
https://www.tiobe.com/tiobe-index/ - Stack Overflow: Most Loved, Dreaded & Wanted Programming Languages In 2020
https://fossbytes.com/stack-overflow-most-loved-dreaded-wanted-programming-languages-in-2020/ - How to Install and Use R on Ubuntu
https://itsfoss.com/install-r-ubuntu/ - R programming for beginners – Why you should use R
https://www.youtube.com/watch?v=9kYUGMg_14s - GOTO 2012 • The R Language The Good The Bad & The Ugly
https://www.youtube.com/watch?v=6S9r_YbqHy8 - R vs Python – What should I learn in 2020? | R and Python Comparison
https://www.youtube.com/watch?v=eRP_J2yLjSU - R Programming 101
https://www.youtube.com/c/rprogramming101 - Seriál Tvorba grafů pomocí programu „R“
https://www.root.cz/serialy/tvorba-grafu-pomoci-programu-r/ - Tvorba grafů pomocí programu „R“: úvod
https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-1/ - Tvorba grafů pomocí programu „R“: pokročilé funkce
https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-pokrocile-funkce/ - Tvorba grafů pomocí programu „R“: vkládání textu, čeština
https://www.root.cz/clanky/grafy-pomoci-programu-r-vkladani-textu-cestina/ - Cesta erka: Krok nultý – instalace & nastavení – prostředí, projekty, package
https://www.jla-data.net/r4su/r4su-environment-setup/ - Cesta erka: Krok první – operace a struktury – proměnné, rovnítka a dolary
https://www.jla-data.net/r4su/r4su-data-structures/ - Cesta erka: Krok druhý – načtení externích dat – csvčka, excely a databáze
https://www.jla-data.net/r4su/r4su-read-data/ - Cesta erka: Krok třetí – manipulace s daty – dplyr, slovesa a pajpy
https://www.jla-data.net/r4su/r4su-manipulate-data/ - Cesta erka: Krok čtvrtý – podání výsledků – ggplot, geomy a estetiky
https://www.jla-data.net/r4su/r4su-report-results/ - Cesta erka: Krok pátý – case study – případ piva v Praze
https://www.jla-data.net/r4su/r4su-case-study-beer/ - 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/ - Is R Programming SURGING in Popularity in 2020?
https://www.youtube.com/watch?v=Duwn-vImyXE - Using the R programming language in Jupyter Notebook
https://docs.anaconda.com/anaconda/navigator/tutorials/r-lang/ - Using R on Jupyter Notebook
https://dzone.com/articles/using-r-on-jupyternbspnotebook - Graphics, ggplot2
http://r4stats.com/examples/graphics-ggplot2/ - A Practice Data Set
https://r4stats.wordpress.com/examples/mydata/ - Shiny – galerie projektů
https://shiny.rstudio.com/gallery/ - Seriál Programovací jazyk Julia
https://www.root.cz/serialy/programovaci-jazyk-julia/ - Julia (front page)
http://julialang.org/ - Julia – repositář na GitHubu
https://github.com/JuliaLang/julia - Julia (programming language)
https://en.wikipedia.org/wiki/Julia_%28programming_language%29 - IJulia
https://github.com/JuliaLang/IJulia.jl - Introducing Julia
https://en.wikibooks.org/wiki/Introducing_Julia - Julia: the REPL
https://en.wikibooks.org/wiki/Introducing_Julia/The_REPL - Introducing Julia/Metaprogramming
https://en.wikibooks.org/wiki/Introducing_Julia/Metaprogramming - Month of Julia
https://github.com/DataWookie/MonthOfJulia - Learn X in Y minutes (where X=Julia)
https://learnxinyminutes.com/docs/julia/ - New Julia language seeks to be the C for scientists
http://www.infoworld.com/article/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html - Julia: A Fast Dynamic Language for Technical Computing
http://karpinski.org/publications/2012/julia-a-fast-dynamic-language - The LLVM Compiler Infrastructure
http://llvm.org/ - Julia: benchmarks
http://julialang.org/benchmarks/ - R Vector
https://www.datamentor.io/r-programming/vector/ - .R File Extension
https://fileinfo.com/extension/r - Lineární regrese
https://cs.wikipedia.org/wiki/Line%C3%A1rn%C3%AD_regrese - lm (funkce)
https://www.rdocumentation.org/packages/stats/versions/3.6.2/topics/lm - quit (funkce)
https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/quit - c (funkce)
https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/c - help (funkce)
https://www.rdocumentation.org/packages/utils/versions/3.6.2/topics/help - Shiny: Introduction to interactive documents
https://shiny.rstudio.com/articles/interactive-docs.html - R Release History 1997–2013
http://timelyportfolio.github.io/rCharts_timeline_r/ - R: atomic vectors
https://renenyffenegger.ch/notes/development/languages/R/data-structures/vector/ - 11 Best R Programming IDE and editors
https://www.dunebook.com/best-r-programming-ide/ - CRAN – The Comprehensive R Archive Network
https://cran.r-project.org/
ČLÁNKY DO MAILU