Hlavní navigace

Podrobnější popis vlastností programovacího jazyka R

14. 1. 2021
Doba čtení: 31 minut

Sdílet

 Autor: R Core Team
Psát užitečné skripty v jazyce R je možné i bez detailní znalosti jeho syntaxe a sémantiky. I proto se k tomuto tématu dostáváme až ve třinácté části seriálu o R. Popíšeme si vlastnosti datových typů i všechny nabízené řídicí konstrukce.

Obsah

1. Základní operace s balíčky

2. Instalace nového balíčku

3. Datové typy a proměnné

4. Deklarace proměnných

5. Základní funkce pro práci s proměnnými

6. Automatické převody mezi hodnotami různých typů

7. Explicitní datové konverze

8. Hodnoty Inf, -Inf a NaN

9. Aritmetické a relační operace s hodnotou NaN

10. Speciální hodnota NA a její varianty

11. Řízení toku programu v jazyce R

12. Podmínky realizované konstrukcí if

13. Konstrukce ifelse

14. Konstrukce switch

15. Programová smyčka typu repeat

16. Programová smyčka typu while

17. Programová smyčka typu for

18. Seznam dnes použitých funkcí

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

20. Odkazy na Internetu

1. Balíčky

Nejprve si popišme (popř. připomeňme) základní funkce používané pro práci s balíčky. Každý balíček typicky obsahuje sadu funkcí s jejich dokumentací, ovšem mnohdy obsahuje i testovací data, nápovědu k použití těchto testovacích dat a některé balíčky jsou založeny na nativních funkcích překládaných a linkovaných v rámci instalace balíčku.

Pokud je nějaký balíček již nainstalován a je nutné ho použít, lze takový balíček načíst příkazem require:

> require(lattice)
 
Loading required package: lattice

Popř. se použije příkaz library:

> library(lattice)
Poznámka: povšimněte si, že se jméno balíčku zapisuje bez uvozovek.

Při pokusu inicializovat neexistující balíček dojde k chybě:

> library(foobar)
Error in library(foobar) : there is no package called ‘foobar’

K balíčku je možné zobrazit dokumentaci zadáním příkazu help, kterému se předá jméno balíčku:

> help(lattice)

V tomto případě s výsledkem:

A_01_Lattice              package:lattice              R Documentation
 
Lattice Graphics
 
Description:
 
     The ‘lattice’ add-on package is an implementation of Trellis
     graphics for R.  It is a powerful and elegant high-level data
     visualization system with an emphasis on multivariate data.  It is
     designed to meet most typical graphics needs with minimal tuning,
     but can also be easily extended to handle most nonstandard
     requirements.
 
Details:
 
     Trellis Graphics, originally developed for S and S-PLUS at the
     Bell Labs, is a framework for data visualization developed by R.
     A. Becker, W. S. Cleveland, et al, extending ideas presented in
     Cleveland's 1993 book _Visualizing Data_.  The Lattice API is
     based on the original design in S, but extends it in many ways.
 
     The Lattice user interface primarily consists of several
     ‘high-level’ generic functions (listed below in the “See Also”
     section), each designed to create a particular type of display by

Pro zjištění informací o nainstalovaných balíčcích se používá příkaz installed.packages, který vrací tabulku s následujícími informacemi o každém balíčku:

  • Package
  • LibPath
  • Version
  • Priority
  • Depends
  • Imports
  • LinkingTo
  • Suggests
  • Enhances
  • OS Type
  • License
  • Built
Poznámka: některé údaje nemusí být vyplněny.

Příklad výsledku pro čistě nainstalovaný jazyk R bez dalších doplňujících balíčků:

> installed.packages()
           Package      LibPath                Version    Priority
base       "base"       "/usr/lib64/R/library" "3.6.3"    "base"
boot       "boot"       "/usr/lib64/R/library" "1.3-24"   "recommended"
class      "class"      "/usr/lib64/R/library" "7.3-15"   "recommended"
cluster    "cluster"    "/usr/lib64/R/library" "2.1.0"    "recommended"
codetools  "codetools"  "/usr/lib64/R/library" "0.2-16"   "recommended"
compiler   "compiler"   "/usr/lib64/R/library" "3.6.3"    "base"
foreign    "foreign"    "/usr/lib64/R/library" "0.8-75"   "recommended"
graphics   "graphics"   "/usr/lib64/R/library" "3.6.3"    "base"
 
 
           Depends
base       NA
boot       "R (>= 3.0.0), graphics, stats"
class      "R (>= 3.0.0), stats, utils"
cluster    "R (>= 3.3.0)"
codetools  "R (>= 2.1)"
compiler   NA
datasets   NA
foreign    "R (>= 3.0.0)"
 
           Imports                                            LinkingTo
base       NA                                                 NA
boot       NA                                                 NA
class      "MASS"                                             NA
cluster    "graphics, grDevices, stats, utils"                NA
codetools  NA                                                 NA
compiler   NA                                                 NA
datasets   NA                                                 NA
foreign    "methods, utils, stats"                            NA
 
           Suggests
base       "methods"
boot       "MASS, survival"
class      NA
cluster    "MASS, Matrix"
codetools  NA
compiler   NA
datasets   NA
foreign    NA
graphics   NA
 
           Enhances                                License
base       NA                                      "Part of R 3.6.3"
boot       NA                                      "Unlimited"
class      NA                                      "GPL-2 | GPL-3"
cluster    NA                                      "GPL (>= 2)"
codetools  NA                                      "GPL"
compiler   NA                                      "Part of R 3.6.3"
datasets   NA                                      "Part of R 3.6.3"
foreign    NA                                      "GPL (>= 2)"
graphics   NA                                      "Part of R 3.6.3"
 
           License_is_FOSS License_restricts_use OS_type MD5sum
base       NA              NA                    NA      NA
boot       NA              NA                    NA      NA
class      NA              NA                    NA      NA
cluster    NA              NA                    NA      NA
codetools  NA              NA                    NA      NA
compiler   NA              NA                    NA      NA
datasets   NA              NA                    NA      NA
foreign    NA              NA                    NA      NA
graphics   NA              NA                    NA      NA
 
           NeedsCompilation Built
base       NA               "3.6.3"
boot       "no"             "3.6.3"
class      "yes"            "3.6.3"
cluster    "yes"            "3.6.3"
codetools  "no"             "3.6.3"
compiler   NA               "3.6.3"
datasets   NA               "3.6.3"
foreign    "yes"            "3.6.3"
graphics   "yes"            "3.6.3"
Poznámka: seznam balíčků ze standardní knihovny naleznete na stránce https://stat.ethz.ch/R-manual/R-devel/doc/html/packages.html.

2. Instalace nového balíčku

Instalaci nového balíčku lze provést příkazem install.packages, kterému se předá jméno požadovaného balíčku. Seznam dostupných balíčků naleznete například na adrese https://cran.r-project.org/web/packages/a­vailable_packages_by_name­.html:

< install.packages("ggplot2")

Instalační proces ze zpočátku zeptá na volbu umístění serveru se zrcadlem balíčků (ovšem geograficky bližší server nemusí být nutně rychlejší):

Installing package into ‘/usr/lib64/R/library’
(as ‘lib’ is unspecified)
--- Please select a CRAN mirror for use in this session ---
Secure CRAN mirrors
 
 1: 0-Cloud [https]
 2: Australia (Canberra) [https]
 3: Australia (Melbourne 1) [https]
 4: Australia (Melbourne 2) [https]

Konkrétně v případě balíčku ggplot2 dochází k překladu nativních knihoven s využitím překladače jazyka C++:

...
...
...
** building package indices
** installing vignettes
** testing if installed package can be loaded from temporary location
** testing if installed package can be loaded from final location
** testing if installed package keeps a record of temporary installation path
* DONE (ggplot2)
Making 'packages.html' ... done
 
The downloaded source packages are in
        ‘/tmp/RtmpvIdtKQ/downloaded_packages’
Updating HTML index of packages in '.Library'
Making 'packages.html' ... done

Vidíme, že se na konci instalace upravila nápověda dostupná lokálně.

3. Datové typy a proměnné

S některými datovými typy programovacího jazyka R jsme se již seznámili v předchozích částech tohoto seriálu. Připomeňme si tedy, že tento programovací jazyk podporuje práci s následujícími datovými typy:

# Datový typ
1 Vektory
2 Seznamy
3 Factory
4 Pole
5 Matice
6 Datové rámce

Nejjednodušším typem z předchozí šestice jsou vektory, které mohou v limitním případě obsahovat jediný prvek, který by byl v jiných programovacích jazycích považován za skalár. Existuje přitom šest datových typů takzvaných atomických vektorů (může to být matoucí, ale v tomto kontextu se setkáme i s označením „třída vektoru“):

# Režim Typ (třída) atomického vektoru Příklad
1 Logical Logical TRUE, FALSE
2 Numeric Double 3.14, 1000, 10000.5
3 Numeric Integer 42L, 0L
4 Complex Complex 1 + 2i
5 Character Character „Hello“
6 Raw Raw charToRaw(„Hello“)
Poznámka: poněkud zvláštní je především druhý, třetí a čtvrtý řádek tabulky, tedy například Numeric, resp. Double. V případě Double se jedná o hodnoty s plovoucí řádovou tečkou (tedy hodnoty používané i v dalších programovacích jazycích a podporované matematickými koprocesory). Z historických důvodů (objektový systém S3) ovšem pro tyto hodnoty vrací funkce class zmíněná níže „numeric“, kdežto funkce typeof vrací „double“. Vztah mezi numerickými typy je možné si zobrazit pomocí predikátů is.TYP:

Číslo s plovoucí řádovou čárkou

> x <- 3.14
> is.numeric(x)
[1] TRUE
 
> is.integer(x)
[1] FALSE
 
> is.double(x)
[1] TRUE
 
> is.complex(x)
[1] FALSE

Celé číslo

> x <- 1L
 
> is.numeric(x)
[1] TRUE
 
> is.integer(x)
[1] TRUE
 
> is.double(x)
[1] FALSE
 
> is.complex(x)
[1] FALSE

Komplexní číslo

> x <- 1+2i
 
> is.numeric(x)
[1] TRUE
 
> is.integer(x)
[1] FALSE
 
[1] FALSE
> is.double(x)
[1] FALSE
 
> is.complex(x)
[1] TRUE
Poznámka: existují i další podobné predikáty, zejména is.vector a is.atomic, ovšem jejich praktické použití je poměrně problematické (a většinou ani není nutné).

4. Deklarace proměnných

Proměnné se deklarují (vytváří) přiřazením nové hodnoty (libovolného typu) do proměnné s využitím operátoru ← popř. operátoru =. Při deklaraci proměnných však není nutné datový typ explicitně specifikovat, protože se dynamicky odvodí z hodnoty, která je do proměnné přiřazována. Typ (resp. v řeči jazyka R spíše třídu) proměnné lze zjistit standardní funkcí class, takže si vyzkoušejme několik příkladů:

> x <- 10
> class(x)
[1] "numeric"
 
> x <- 10L
> class(x)
[1] "integer"
 
> x <- 1+2i
> class(x)
[1] "complex"
 
> x <- "Hello world!"
> class(x)
[1] "character"
 
> x <- charToRaw("Hello")
> class(x)
[1] "raw"
 
> x <- TRUE
> class(x)
[1] "logical"
Poznámka: povšimněte si, že se v prvním případě (z historických důvodů) vrací „numeric“ a nikoli „double“.

Režim uložení libovolné hodnoty se zjistí funkcí nazvanou typeof:

> x <- 10
> typeof(x)
[1] "double"
 
> x <- 10L
> typeof(x)
[1] "integer"
 
> x <- 1+2i
> typeof(x)
[1] "complex"
 
> x <- "Hello world!"
> typeof(x)
[1] "character"
 
> x <- charToRaw("Hello")
> typeof(x)
[1] "raw"
 
> x <- TRUE
> typeof(x)
[1] "logical"

Posledním důležitým plnohodnotným datovým typem jsou funkce, kterými se budeme zabývat v samostatné kapitole:

> f <- function() {42}
 
> f
function() {42}
 
> f()
[1] 42
 
> class(f)
[1] "function"
 
> typeof(f)
[1] "closure"

5. Základní funkce pro práci s proměnnými

Pro práci s proměnnými je k dispozici několik funkcí, které je možné použít pro prakticky libovolné hodnoty:

# Funkce Stručný popis funkce
1 ls() vrátí vektor se jmény všech viditelných objektů
2 str(x) zobrazení objektu v čitelné podobě
3 head(x) zobrazení první části obsahu proměnné (vektoru, pole, datového rámce atd.)
4 tail(x) zobrazení poslední části obsahu proměnné (vektoru, pole, datového rámce atd.)
5 class(x) zobrazení třídy (typu) hodnoty navázané na proměnnou (bylo popsáno ve čtvrté kapitole)
6 typeof(x) zobrazení režimu uložení hodnoty navázané na proměnnou (bylo popsáno ve čtvrté kapitole)
7 rm(x) odstranění objektů z operační paměti

Následují příklady použití těchto funkcí:

> v <- 1:100
 
> head(v)
[1] 1 2 3 4 5 6
 
> tail(v)
[1]  95  96  97  98  99 100
 
> class(v)
[1] "integer"
 
> typeof(v)
[1] "integer"
 
> str(v)
 int [1:100] 1 2 3 4 5 6 7 8 9 10 ...
 
> ls()
[1] "i" "v" "x"

Specifikace počtu zobrazených prvků ze začátku, resp. konce obsahu proměnné:

> head(v, 10)
 [1]  1  2  3  4  5  6  7  8  9 10
 
> tail(v, 10)
 [1]  91  92  93  94  95  96  97  98  99 100

Použít je však možné i záporné indexy, které určují, kolik prvků od konce/začátku má být z výpisu vynecháno:

> head(v, -10)
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
[51] 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
[76] 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
 
> tail(v, -10)
 [1]  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29
[20]  30  31  32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48
[39]  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67
[58]  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86
[77]  87  88  89  90  91  92  93  94  95  96  97  98  99 100

6. Automatické převody mezi hodnotami různých typů

Typový systém programovacího jazyka R se chová poněkud zvláštním způsobem, což může vést k mnoha „záhadným“ chybám. V některých případech provádí automatickou typovou konverzi tak, aby například byly oba operandy nějakého binárního operátoru kompatibilní. Například:

> 1 == "1"
[1] TRUE

V tomto případě je první operand taktéž převeden na řetězec.

U vektorů platí, že všechny jejich prvky musí být stejného typu, takže i zde dochází k automatickým typovým konverzím.

Dvě hodnoty typu double, resp. numeric:

> x <- c(1, 1)
> x
[1] 1 1
 
> class(x)
[1] "numeric"

Hodnoty různého typu (druhé číslo je v tomto příkladu typu integer):

> x <- c(1, 1L)
> x
[1] 1 1
> class(x)
[1] "numeric"

Dva prvky typu integer:

> x <- c(1L, 1L)
> x
[1] 1 1
> class(x)
[1] "integer"

Jeden z prvků je komplexní číslo:

> x <- c(1, 1+2i)
> x
[1] 1+0i 1+2i
> class(x)
[1] "complex"

Jeden z prvků je řetězcem:

> x <- c(1, "1")
> x
[1] "1" "1"
> class(x)
[1] "character"

Automatické typové konverze se provádí i při spuštění některých funkcí:

> x <- c(TRUE, FALSE, TRUE, FALSE)
 
> x
[1]  TRUE FALSE  TRUE FALSE
 
> sum(x)
[1] 2
> mean(x)
[1] 0.5

Ovšem například řetězce se na číselné hodnoty automaticky nepřevádí:

> y <- c("1", "2", "3", "4")
 
> y
[1] "1" "2" "3" "4"
 
> class(y)
[1] "character"
 
> sum(y)
Error in sum(y) : invalid 'type' (character) of argument

7. Explicitní datové konverze

Převod (tedy konverzi) na jiný datový typ lze provést i explicitně, a to s využitím následujících funkcí:

# Jméno funkce Stručný popis funkce
1 as.logical převod na typ Logical
2 as.integer převod na typ Integer
3 as.double převod na typ Double
4 as.character převod na typ Character

Opět si ukážeme některé příklady použití:

> x <- c(TRUE, FALSE, TRUE, FALSE)
 
> as.numeric(x)
[1] 1 0 1 0
 
> x
[1]  TRUE FALSE  TRUE FALSE

Převod číselných hodnot uložených v řetězcích je možný:

> as.integer(c("1", "2", "3"))
[1] 1 2 3
 
> as.complex(c("1+2i"))
[1] 1+2i

Zpětný převod (numerické hodnoty na řetězec):

> as.character(c(1, 2, 3, 4))
[1] "1" "2" "3" "4"

Převod na vektor logických hodnot:

> as.logical(c(0, 1, 2, -1))
[1] FALSE  TRUE  TRUE  TRUE

Pokud nějakou hodnotu konvertovat nelze, což je příklad řetězce „a“ převáděného na celé číslo, bude tato hodnota nahrazena za NA a přitom se vypíše varování:

> as.integer(c("1", "1.5", "a"))
[1]  1  1 NA
Warning message:
NAs introduced by coercion
 
 
> as.double(c("1", "1.5", "a"))
[1] 1.0 1.5  NA
Warning message:
NAs introduced by coercion

Některé konverze mohou vést k částečné ztrátě informací; opět se zobrazí varování:

> as.integer(c(1, 2L, 3.14, 5+6i))
[1] 1 2 3 5
Warning message:
imaginary parts discarded in coercion

8. Hodnoty Inf, -Inf a NaN

Programovací jazyk R je mj. určen pro zpracování dat získaných z různých zdrojů i pro numerické výpočty. Z tohoto důvodu podporuje jak speciální hodnotu NaN značící „not a number“ (což ale není totéž jako hodnota NA), tak i hodnoty Inf a -Inf reprezentující kladné a záporné nekonečno. S těmito hodnotami lze provádět i aritmetické operace atd.

Typ těchto hodnot je Numeric:

> x <- Inf
> class(x)
[1] "numeric"
 
> x <- -Inf
> class(x)
[1] "numeric"
 
> x <- NaN
> class(x)
[1] "numeric"

Nyní si vyzkoušejme některé aritmetické operace s hodnotou Inf:

> x <- Inf
 
> -x
[1] -Inf
 
> x + 0
[1] Inf
 
> x + 10
[1] Inf
 
> x * 0
[1] NaN
 
> x * 10
[1] Inf
 
> x - x
[1] NaN
 
> x / x
[1] NaN
Poznámka: povšimněte si, že některé operace vrací NaN!

Základní relační operace pracují s nekonečnem podle předpokladů:

> x <- Inf
 
> x < 0
[1] FALSE
 
> x > 0
[1] TRUE
 
> x == 0
[1] FALSE

Ovšem nikoli již v kombinaci s nějakou aritmetickou operací!:

> x <- Inf
 
> x < x * 2
[1] FALSE
 
> x < x + 1
[1] FALSE

9. Aritmetické a relační operace s hodnotou NaN

Aritmetické operace s hodnotou NaN mají prakticky vždy stejný výsledek – opět NaN, což ostatně odpovídá i normě IEEE 794:

> x <- NaN
 
> -x
[1] NaN
 
> x + 0
[1] NaN
 
> x + 10
[1] NaN
 
> x * 0
[1] NaN
 
> x * 10
[1] NaN
 
> x - x
[1] NaN
 
> x / x
[1] NaN

Speciální chování nalezneme u relačních operátorů, protože v tomto ohledu se jazyk R odlišuje od mnoha jiných jazyků, protože vrací hodnotu NA a nikoli FALSE:

> x <- NaN
 
> x < 0
[1] NA
 
> x > 0
[1] NA
 
> x == 0
[1] NA
 
> x < NaN
[1] NA
 
> x > NaN
[1] NA
 
> x == NaN
[1] NA

Totéž platí i pro kombinaci relačního operátoru s operátorem aritmetickým:

> x <- NaN
 
> x < x * 2
[1] NA
 
> x < x + 1
[1] NA
 
> x > x * 2
[1] NA
 
> x > x + 1
[1] NA

10. Speciální hodnota NA a její varianty

Při zpracování reálných dat se nevyhneme situacím, kdy nějaké údaje zcela chybí. V programovacím jazyku R mohou být takové neexistující údaje reprezentovány speciální hodnotou NA neboli „Not Available“. Tato speciální hodnota může být použita v aritmetických operacích, což mj. naznačuje, že se jedná o koncepční rozdíl oproti NULL či None (spíše se blíží koncepci nil v LISPovských jazycích podporujících „nil punning“:

> NA+NA
[1] NA
 
> NA-NA
[1] NA
 
> NA+1
[1] NA
 
> NA*2
[1] NA
 
> NA+Inf
[1] NA
 
> NA/Inf
[1] NA

Výsledky porovnání (relačních operací):

> NA > 42
[1] NA
 
> NA < 42
[1] NA
 
> NA == 42
[1] NA
 
> NA == NA
[1] NA
 
> NA != NA
[1] NA

Výsledky logických a bitových operací – pozor na to, že zde NA skutečně vystupuje v roli „zde nic není“, což ovlivňuje operaci logického součtu a logického součinu:

> !NA
[1] NA
 
> NA | TRUE
[1] TRUE
 
> NA & FALSE
[1] FALSE
 
> NA ^ 0
[1] 1
Poznámka: ve skutečnosti pro každý datový typ existuje zvláštní hodnota NA, ovšem v praxi tyto hodnoty prakticky nikdy nepoužijeme, protože se provádí automatické přetypování na NA:
> NA_integer_ + 1
[1] NA
 
> NA_real_ * 2.4
[1] NA
 
> NA_character_
[1] NA

11. Řízení toku programu v jazyce R

V programovacím jazyku R pochopitelně nalezneme i konstrukce určené pro řízení toku programu. Prozatím jsme se s nimi nesetkali, a to zejména z toho důvodu, že mnoho skriptů zpracovávajících data se bez těchto relativně nízkoúrovňových konstrukcí bez problému obejde (což ostatně platí i pro další doménově specifické jazyky typu Matlab atd.):

# Konstrukce Stručný popis programové konstrukce
1 if rozvětvení na základě vyhodnocené podmínky
2 ifelse aplikace podmínky na všechny prvky datového typu
3 switch rozvětvení na základě numerické hodnoty nebo řetězce
4 repeat nekonečná programová smyčka
5 while programová smyčka s testem na začátku
6 for programová smyčka procházející prvky datového typu

Jednotlivé konstrukce budou podrobněji popsány v navazujících kapitolách.

Poznámka: ve skutečnosti se v mnoha skriptech s žádnými řídicími strukturami nesetkáme, protože se pracuje vždy s celými vektory či s datovými rámci.

12. Podmínky realizované konstrukcí if

V programovacím jazyku R se používá klasická rozhodovací konstrukce (větvení) pojmenovaná if. Tato konstrukce existuje ve dvou variantách – bez větve else a s větví else (což opět koresponduje s většinou ostatních mainstreamových programovacích jazyků):

if (podmínka) větev_true
if (podmínka) větev_true else větev_false

Podmínkou je zde myšlen výraz vyhodnocený na TRUE či FALSE; samotné větve mohou taktéž obsahovat jediný výraz, jehož hodnota je vrácena:

> x1 <- if (TRUE) 1 else 2
> x2 <- if (FALSE) 1 else 2
 
> x1
[1] 1
 
> x2
[1] 2

Celočíselné hodnoty jsou převáděny na TRUE/FALSE podle běžných zvyklostí (0=FALSE, vše ostatní je TRUE):

> if (1) "yes" else "no"
[1] "yes"
 
> if (0) "yes" else "no"
[1] "no"

Ovšem pozor na to, že totéž neplatí o celočíselných hodnotách v řetězci:

> if ("1") "yes" else "no"
Error in if ("1") "yes" else "no" :
  argument is not interpretable as logical

Z předchozích kapitol již víme, že výsledkem mnoha operací může být hodnota NA. Tu ovšem přímo v podmínce použít nelze:

> if (NA) "yes" else "no"
Error in if (NA) "yes" else "no" : missing value where TRUE/FALSE needed

Pokud se v podmínce vyskytne vektor s více prvky (což může být časté), testuje se pouze první prvek tohoto vektoru a navíc se uživateli vypíše varování o provedené operaci:

> if (c(TRUE, FALSE)) "yes" else "no"
[1] "yes"
Warning message:
In if (c(TRUE, FALSE)) "yes" else "no" :
  the condition has length > 1 and only the first element will be used
 
> if (c(FALSE, FALSE)) "yes" else "no"
[1] "no"
Warning message:
In if (c(FALSE, FALSE)) "yes" else "no" :
  the condition has length > 1 and only the first element will be used

Toto chování (které může být zbytečně benevolentní) je možné vypnout tímto trikem:

> Sys.setenv("_R_CHECK_LENGTH_1_CONDITION_" = "true")
 
> if (c(TRUE, FALSE)) "yes" else "no"
Error in if (c(TRUE, FALSE)) "yes" else "no" :
  the condition has length > 1
 
> if (c(FALSE, FALSE)) "yes" else "no"
Error in if (c(FALSE, FALSE)) "yes" else "no" :
  the condition has length > 1

Složitější konstrukce s vnořenými konstrukcemi if-else:

grade <- 0
 
if (grade >= 95) {
    "A"
} else if (grade >= 80) {
    "B"
} else if (grade >= 70) {
    "C"
} else if (grade >= 55) {
    "D"
} else {
    "E"
}

13. Konstrukce ifelse

V mnoha případech se stane, že potřebujeme zpracovat celý vektor dat na základě nějaké podmínky aplikované na jednotlivé prvky vektoru. Tuto činnost zajišťuje konstrukce ifelse, která je zapisována formou volání funkce, i když se ve skutečnosti o tradiční funkci nejedná. Do ifelse se zapíše podmínka (viz předchozí kapitolu), hodnota či výraz použitý při splnění podmínky a hodnota či výraz použitý při jejím nesplnění:

Vytvoření nového vektoru, který bude obsahovat informaci o tom, zda byl prvek původního vektoru sudý nebo lichý (zdrojový vektor obsahuje hodnoty od 1 do 10 včetně):

> x <- 1:10
 
> ifelse(x %% 2 == 0, "even", "odd")
 [1] "odd"  "even" "odd"  "even" "odd"  "even" "odd"  "even" "odd"  "even"

Použití složitějších výrazů:

> x <- 1:10
 
> ifelse(x %% 2 == 0, "even", x)
 [1] "1"    "even" "3"    "even" "5"    "even" "7"    "even" "9"    "even"
 
> ifelse(x %% 2 == 0, x*10, 1/x)
 [1]   1.0000000  20.0000000   0.3333333  40.0000000   0.2000000  60.0000000
 [7]   0.1428571  80.0000000   0.1111111 100.0000000
Poznámka: pozor na typ výsledného vektoru v případě, že jeden výraz bude vracet hodnoty odlišného typu!

14. Konstrukce switch

Vraťme se na chvíli k poněkud složitější konstrukci if-else s několika postupně vyhodnocovanými podmínkami. V takové konstrukci můžeme snadno reagovat na neplatný vstup:

input <- 3
 
if (input == 0) {
    "zero"
} else if (input == 1) {
    "one"
} else if (input == 2) {
    "two"
} else {
    stop("Invalid `input` value")
}

Otestování v praxi:

> input <- 2
>
> if (input == 0) {
+     "zero"
+ } else if (input == 1) {
+     "one"
+ } else if (input == 2) {
+     "two"
+ } else {
+     stop("Invalid `input` value")
+ }
[1] "two"
 
> input <- 3
>
> if (input == 0) {
+     "zero"
+ } else if (input == 1) {
+     "one"
+ } else if (input == 2) {
+     "two"
+ } else {
+     stop("Invalid `input` value")
+ }
Error: Invalid `input` value

Jedná se ovšem o zbytečně složitý zápis, protože stejného chování můžeme dosáhnout konstrukcí pojmenovanou switch, která se v programovacím jazyku R opět zapisuje tak, jakoby se jednalo o volání funkce. Prvním parametrem je výraz, jehož výsledek určuje, který z dalších parametrů se má vrátit jako výsledek. Pokud je výraz vyhodnocen na celé číslo, vrátí se n-tý parametr (po svém vyhodnocení). Parametry jsou očíslovány od jedničky:

input <- 0
 
switch(input+1,
    "zero",
    "one",
    "two",
    stop("Invalid `input` value")
)

Poněkud odlišného chování dosáhneme tehdy, pokud se použije následující zápis. Ten nám umožní vybírat hodnoty na základě řetězců (klíčů) uvedených před znakem „=“:

command <- "color"
 
switch(command,
       "color" = "red",
       "shape" = "square",
       "length" = 5)
 
"red"
command <- "shape"
 
switch(command,
       "color" = "red",
       "shape" = "square",
       "length" = 5)
 
"square"
command <- "length"
 
switch(command,
       "color" = "red",
       "shape" = "square",
       "length" = 5)
 
5

Při výběru může dojít k vyhodnocení NA tehdy, pokud není řetězec v množině klíčů nalezen:

command <- "foobar"
 
switch(command,
       "color" = "red",
       "shape" = "square",
       "length" = 5)
 

Ovšem chybu můžeme nahlásit i explicitně:

command <- "foobar"
 
switch(command,
       "color" = "red",
       "shape" = "square",
       "length" = 5)
       stop("Invalid `input` value"))
 
Error: Invalid `input` value
Poznámka: z uvedených příkladů je zřejmé, že i když se switch zapisuje formou volání funkce, ve skutečnosti se o funkci v žádném případě nejedná – sémantika je odlišná!

15. Programová smyčka typu repeat

Dalším typem řídicích konstrukcí jsou programové smyčky. Nejuniverzálnější a současně i nejjednodušší je smyčka typu repeat. Jedná se o nekonečnou smyčku, jejíž základní podoba vypadá následovně:

repeat print("Diamonds are forever")
 
[1] "Diamonds are forever"
[1] "Diamonds are forever"
[1] "Diamonds are forever"
...
...
...

Častěji se ovšem setkáme s použitím blokových závorek, což nám umožňuje zápis více výrazů do těla smyčky:

repeat {
    print("Diamonds are forever")
}
 
[1] "Diamonds are forever"
[1] "Diamonds are forever"
[1] "Diamonds are forever"
...
...
...

Explicitně vytvořené počitadlo v nekonečné smyčce:

i <- 0
repeat {
    i <- i + 1
    print(i)
}
 
[1] 1
[1] 2
[1] 3
...
...
...

Tuto smyčku (a i další dvě typy programových smyček) je možné ukončit příkazem break známým z dalších programovacích jazyků:

i <- 10
repeat {
    print(i)
    i <- i - 1
    if (i == 0)
        break
}
 
[1] 10
[1] 9
[1] 8
[1] 7
[1] 6
[1] 5
[1] 4
[1] 3
[1] 2
[1] 1

Použít lze i příkaz next, který má stejný význam jako continue známý z céčkové větve programovacích jazyků:

i <- 0
repeat {
    i <- i + 1
    if (i <= 5)
        next
    print(i)
    if (i >= 10)
        break
}
 
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10

16. Programová smyčka typu while

V jazyku R nalezneme i programovou smyčku typu while, v níž se podmínka (jak bývá zvykem už od dob Algolu) zapisuje před tělo smyčky, protože se taktéž vyhodnocuje před vstupem do smyčky (tedy před začátkem další iterace. Základní forma této smyčky vypadá následovně:

while(podmínka) příkaz

Častěji se však používají blokové závorky:

while(podmínka) {
    příkaz
    ...
    ...
    ...
}

Příklad smyčky s explicitně použitým počitadlem:

i <- 10
while (i > 0) {
    print(i)
    i <- i - 1
}
 
[1] 10
[1] 9
[1] 8
[1] 7
[1] 6
[1] 5
[1] 4
[1] 3
[1] 2
[1] 1

Nepatrně složitější výpočet:

i <- 1
while (i < 100000) {
    print(i)
    i <- i * 2
}
 
[1] 1
[1] 2
[1] 4
[1] 8
[1] 16
[1] 32
[1] 64
[1] 128
[1] 256
[1] 512
[1] 1024
[1] 2048
[1] 4096
[1] 8192
[1] 16384
[1] 32768
[1] 65536

I v této smyčce je možné použít příkaz break:

i <- 1
while (TRUE) {
    print(i)
    i <- i * 2
    if (i > 65536)
        break
}
 
[1] 1
[1] 2
[1] 4
[1] 8
[1] 16
[1] 32
[1] 64
[1] 128
[1] 256
[1] 512
[1] 1024
[1] 2048
[1] 4096
[1] 8192
[1] 16384
[1] 32768
[1] 65536

Použitelný je i příkaz next pro vynechání části těla smyčky:

i <- 1
while (TRUE) {
    i <- i * 2
    if (i > 65536)
        break
    if (i < 1000)
        next
    print(i)
}
 
[1] 1024
[1] 2048
[1] 4096
[1] 8192
[1] 16384
[1] 32768
[1] 65536

17. Programová smyčka typu for

Posledním typem smyčky programovacího jazyka R je smyčka typu for, která se používá pro průchod prvky vektorů, datových rámců atd. Základní tvar této smyčky vypadá následovně:

for (i in 1:10) {
    print(i)
}
 
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10

Na rozdíl od jiných jazyků je proměnná i (řídicí proměnná smyčky) dostupná i mimo její tělo:

> i
[1] 10

Díky tomu, jak jsou v jazyku R konstruovány sekvence, je možné použít i čítač směrem dolů:

for (i in 10:1) {
    print(i)
}
 
[1] 10
[1] 9
[1] 8
[1] 7
[1] 6
[1] 5
[1] 4
[1] 3
[1] 2
[1] 1

I v tomto typu smyčky lze využít příkaz break:

for (i in 1:10) {
    print(i)
    if (i > 5)
        break
}
 
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6

A taktéž příkaz next:

for (i in 1:10) {
    if (i < 5)
        next
    print(i)
}
 
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10

Kombinace obou zmíněných příkazů:

for (i in 1:20) {
    if (i < 5)
        next
    else if (i > 10)
        break
    print(i)
}
 
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10

Průchod prvky vektoru:

v <- c(1, 2, 5, 10)
 
for (i in v) {
    print(i)
}
 
[1] 1
[1] 2
[1] 5
[1] 10

Pozor na použití počitadla při průchodu vektorem. Následující příklad sice bude funkční:

Root tip

v <- c(1, 2, 5, 10)
 
for (i in 1:length(v)) {
    print(i)
}
 
[1] 1
[1] 2
[1] 3
[1] 4

Ale tento již nikoli, protože se vygenerují pouze indexy 1 a 0 (v tomto pořadí):

v <- c()
 
for (i in 1:length(v)) {
    print(i)
}
 
[1] 1
[1] 0

18. Seznam dnes použitých funkcí

# Funkce Stručný popis funkce
1 ls() vektor se jmény všech objektů
2 str(x) zobrazení objektu v čitelné podobě
3 head(x) zobrazení první části obsahu proměnné (vektoru, pole, datového rámce atd.)
4 tail(x) zobrazení poslední části obsahu proměnné (vektoru, pole, datového rámce atd.)
5 class(x) zobrazení třídy (typu) hodnoty navázané na proměnnou (bylo popsáno ve třetí kapitole)
6 typeof(x) zobrazení režimu uložení hodnoty navázané na proměnnou (bylo popsáno ve třetí kapitole)
7 rm(x) odstranění objektů z operační paměti
     
8 is.numeric test na typ parametru funkce
9 is.integer test na typ parametru funkce
10 is.double test na typ parametru funkce
11 is.complex test na typ parametru funkce
     
12 as.logical převod na typ Logical
13 as.integer převod na typ Integer
14 as.double převod na typ Double
15 as.character převod na typ Character
     
16 require načtení zvoleného balíčku
17 library načtení zvoleného balíčku
18 installed.packages seznam všech nainstalovaných balíčků
19 install.packages instalace zvoleného balíčku

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á stále jen jednotky kilobajtů), můžete namísto toho použít odkazy na jednotlivé demonstrační příklady, které naleznete v následující tabulce:

# Demonstrační příklad Stručný popis demonstračního příkladu Cesta
1 function_type.R datový typ „funkce“ https://github.com/tisnik/r-examples/blob/master/12-language-features/function_type.R
       
2 NaN.R aritmetické operace s hodnotou NaN https://github.com/tisnik/r-examples/blob/master/12-language-features/NaN.R
3 NaNRelOp.R porovnání s hodnotou NaN https://github.com/tisnik/r-examples/blob/master/12-language-features/NaNRelOp.R
4 NaNRelOp2.R porovnání s hodnotou NaN https://github.com/tisnik/r-examples/blob/master/12-language-features/NaNRelOp2.R
       
5 NA.R aritmetické operace s hodnotou NA https://github.com/tisnik/r-examples/blob/master/12-language-features/NA.R
       
6 PosInf.R aritmetické operace s hodnotou Inf https://github.com/tisnik/r-examples/blob/master/12-language-features/PosInf.R
7 PosInfRelOp.R porovnání s hodnotou Inf https://github.com/tisnik/r-examples/blob/master/12-language-features/PosInfRelOp.R
8 PosInfRelOp2.R porovnání s hodnotou Inf https://github.com/tisnik/r-examples/blob/master/12-language-features/PosInfRelOp2.R
9 NegInf.R aritmetické operace s hodnotou -Inf https://github.com/tisnik/r-examples/blob/master/12-language-features/NegInf.R
10 NegInfRelOp.R porovnání s hodnotou -Inf https://github.com/tisnik/r-examples/blob/master/12-language-features/NegInfRelOp.R
11 NegInfRelOp2.R porovnání s hodnotou -Inf https://github.com/tisnik/r-examples/blob/master/12-language-features/NegInfRelOp2.R
       
12 repeat1.R nekonečná smyčka typu repeat https://github.com/tisnik/r-examples/blob/master/12-language-features/repeat1.R
13 repeat2.R nekonečná smyčka typu repeat s počitadlem https://github.com/tisnik/r-examples/blob/master/12-language-features/repeat2.R
14 repeat3.R příkaz break ve smyčce typu repeat https://github.com/tisnik/r-examples/blob/master/12-language-features/repeat3.R
15 repeat4.R příkaz next ve smyčce typu repeat https://github.com/tisnik/r-examples/blob/master/12-language-features/repeat4.R
       
16 switch1.R konstrukce switch s celočíselným výrazem https://github.com/tisnik/r-examples/blob/master/12-language-features/switch1.R
17 switch2.R konstrukce switch s řetězci https://github.com/tisnik/r-examples/blob/master/12-language-features/switch2.R

20. Odkazy na Internetu

  1. R Tutorial
    https://www.tutorialspoin­t.com/r/index.htm
  2. Difference between double-precision data type and numeric data type
    https://stackoverflow.com/qu­estions/50255318/differen­ce-between-double-precision-data-type-and-numeric-data-type
  3. R Data Types
    https://www.w3schools.in/r/data-types/
  4. What is the difference between mode and class in R?
    https://stackoverflow.com/qu­estions/35445112/what-is-the-difference-between-mode-and-class-in-r
  5. switch: Select One of a List of Alternatives
    https://rdrr.io/r/base/switch.html
  6. R switch() Function
    https://www.datamentor.io/r-programming/switch-function/
  7. Using ggplot in Python: Visualizing Data With plotnine
    https://realpython.com/ggplot-python/
  8. A Grammar of Graphics for Python
    https://plotnine.readthedoc­s.io/en/stable/
  9. Plotnine gallery
    https://plotnine.readthedoc­s.io/en/latest/gallery.html
  10. plotnine 0.7.1 na PyPi
    https://pypi.org/project/plotnine/
  11. plotnine-examples 0.0.4 na PyPi
    https://pypi.org/project/plotnine-examples/
  12. plotnine examples repository
    https://github.com/has2k1/plotnine-examples
  13. Data visualization in R: cheat sheet
    https://github.com/rstudi­o/cheatsheets/blob/master/da­ta-visualization-2.1.pdf
  14. The R Project for Statistical Computing
    https://www.r-project.org/
  15. An Introduction to R
    https://cran.r-project.org/doc/manuals/r-release/R-intro.pdf
  16. R (programming language)
    https://en.wikipedia.org/wi­ki/R_(programming_language)
  17. The R Programming Language
    https://www.tiobe.com/tiobe-index/r/
  18. R Graphics Second Edition
    https://www.stat.auckland­.ac.nz/~paul/RG2e/
  19. ggplot2 – Introduction
    https://www.tutorialspoin­t.com/ggplot2/ggplot2_intro­duction.htm
  20. ggplot2: Elegant Graphics for Data Analysis
    https://ggplot2-book.org/index.html
  21. Create Elegant Data Visualisations Using the Grammar of Graphics
    https://www.rdocumentation­.org/packages/ggplot2/ver­sions/3.3.2
  22. Grid
    https://www.stat.auckland­.ac.nz/~paul/grid/grid.html
  23. Interactive Course: Data Visualization with lattice in R
    https://www.datacamp.com/courses/data-visualization-in-r-with-lattice
  24. Lattice: trellis graphics for R
    https://lattice.r-forge.r-project.org/
  25. Lattice: Multivariate Data Visualization with R
    http://lmdvr.r-forge.r-project.org/figures/figures.html
  26. Getting Started with Lattice Graphics
    https://lattice.r-forge.r-project.org/Vignettes/src/lattice-intro/lattice-intro.pdf
  27. Using lattice’s xyplot()
    https://homerhanumat.github­.io/tigerstats/xyplot.html
  28. ggplot2 Tutorial
    https://www.tutorialspoin­t.com/ggplot2/index.htm
  29. Lattice Package in R with Functions and Graphs
    https://techvidvan.com/tu­torials/lattice-package-in-r/
  30. The R Graph Gallery
    https://www.r-graph-gallery.com/index.html
  31. Lattice Graphs
    https://www.statmethods.net/ad­vgraphs/trellis.html
  32. ggplot2 (Graph gallery)
    https://www.r-graph-gallery.com/ggplot2-package.html
  33. R Markdown
    https://rmarkdown.rstudio.com/
  34. R Markdown: The Definitive Guide
    https://bookdown.org/yihui/rmarkdown/
  35. R Markdown Cheat Sheet
    https://rstudio.com/wp-content/uploads/2016/03/rmarkdown-cheatsheet-2.0.pdf
  36. Introduction to R Markdown
    https://rmarkdown.rstudio­.com/articles_intro.html
  37. R Cheat Sheets
    https://blog.sergiouri.be/2016/07/r-cheat-sheets.html
  38. R Cheat Sheet
    https://s3.amazonaws.com/quandl-static-content/Documents/Quandl±+R+Che­at+Sheet.pdf
  39. Base R Cheat Sheet
    https://rstudio.com/wp-content/uploads/2016/06/r-cheat-sheet.pdf
  40. PYPL PopularitY of Programming Language
    https://pypl.github.io/PYPL.html
  41. Tiobe index
    https://www.tiobe.com/tiobe-index/
  42. Stack Overflow: Most Loved, Dreaded & Wanted Programming Languages In 2020
    https://fossbytes.com/stack-overflow-most-loved-dreaded-wanted-programming-languages-in-2020/
  43. How to Install and Use R on Ubuntu
    https://itsfoss.com/install-r-ubuntu/
  44. R programming for beginners – Why you should use R
    https://www.youtube.com/wat­ch?v=9kYUGMg_14s
  45. GOTO 2012 • The R Language The Good The Bad & The Ugly
    https://www.youtube.com/wat­ch?v=6S9r_YbqHy8
  46. Intro to Data Visualization with R & ggplot2
    https://www.youtube.com/wat­ch?v=49fADBfcDD4
  47. Plotting with ggplot2: Part 1
    https://www.youtube.com/wat­ch?v=HeqHMM4ziXA
  48. Plotting with ggplot2: Part 2
    https://www.youtube.com/wat­ch?v=n8kYa9vu1l8
  49. R vs Python – What should I learn in 2020? | R and Python Comparison
    https://www.youtube.com/wat­ch?v=eRP_J2yLjSU
  50. R Programming 101
    https://www.youtube.com/c/rpro­gramming101
  51. Seriál Tvorba grafů pomocí programu „R“
    https://www.root.cz/serialy/tvorba-grafu-pomoci-programu-r/
  52. Tvorba grafů pomocí programu „R“: úvod
    https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-1/
  53. Tvorba grafů pomocí programu „R“: pokročilé funkce
    https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-pokrocile-funkce/
  54. Tvorba grafů pomocí programu „R“: vkládání textu, čeština
    https://www.root.cz/clanky/grafy-pomoci-programu-r-vkladani-textu-cestina/
  55. Cesta erka: Krok nultý – instalace & nastavení – prostředí, projekty, package
    https://www.jla-data.net/r4su/r4su-environment-setup/
  56. Cesta erka: Krok první – operace a struktury – proměnné, rovnítka a dolary
    https://www.jla-data.net/r4su/r4su-data-structures/
  57. Cesta erka: Krok druhý – načtení externích dat – csvčka, excely a databáze
    https://www.jla-data.net/r4su/r4su-read-data/
  58. Cesta erka: Krok třetí – manipulace s daty – dplyr, slovesa a pajpy
    https://www.jla-data.net/r4su/r4su-manipulate-data/
  59. Cesta erka: Krok čtvrtý – podání výsledků – ggplot, geomy a estetiky
    https://www.jla-data.net/r4su/r4su-report-results/
  60. Cesta erka: Krok pátý – case study – případ piva v Praze
    https://www.jla-data.net/r4su/r4su-case-study-beer/
  61. 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/
  62. Is R Programming SURGING in Popularity in 2020?
    https://www.youtube.com/watch?v=Duwn-vImyXE
  63. Using the R programming language in Jupyter Notebook
    https://docs.anaconda.com/a­naconda/navigator/tutorial­s/r-lang/
  64. Using R on Jupyter Notebook
    https://dzone.com/articles/using-r-on-jupyternbspnotebook
  65. Graphics, ggplot2
    http://r4stats.com/examples/graphics-ggplot2/
  66. A Practice Data Set
    https://r4stats.wordpress­.com/examples/mydata/
  67. Shiny – galerie projektů
    https://shiny.rstudio.com/gallery/
  68. Seriál Programovací jazyk Julia
    https://www.root.cz/seria­ly/programovaci-jazyk-julia/
  69. Julia (front page)
    http://julialang.org/
  70. Julia – repositář na GitHubu
    https://github.com/JuliaLang/julia
  71. Julia (programming language)
    https://en.wikipedia.org/wi­ki/Julia_%28programming_lan­guage%29
  72. IJulia
    https://github.com/JuliaLan­g/IJulia.jl
  73. Introducing Julia
    https://en.wikibooks.org/wi­ki/Introducing_Julia
  74. Julia: the REPL
    https://en.wikibooks.org/wi­ki/Introducing_Julia/The_REPL
  75. Introducing Julia/Metaprogramming
    https://en.wikibooks.org/wi­ki/Introducing_Julia/Meta­programming
  76. Month of Julia
    https://github.com/DataWo­okie/MonthOfJulia
  77. Learn X in Y minutes (where X=Julia)
    https://learnxinyminutes.com/doc­s/julia/
  78. 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
  79. Julia: A Fast Dynamic Language for Technical Computing
    http://karpinski.org/publi­cations/2012/julia-a-fast-dynamic-language
  80. The LLVM Compiler Infrastructure
    http://llvm.org/
  81. Julia: benchmarks
    http://julialang.org/benchmarks/
  82. R Vector
    https://www.datamentor.io/r-programming/vector/
  83. .R File Extension
    https://fileinfo.com/extension/r
  84. Lineární regrese
    https://cs.wikipedia.org/wi­ki/Line%C3%A1rn%C3%AD_regre­se
  85. lm (funkce)
    https://www.rdocumentation­.org/packages/stats/versi­ons/3.6.2/topics/lm
  86. quit (funkce)
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/quit
  87. c (funkce)
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/c
  88. help (funkce)
    https://www.rdocumentation­.org/packages/utils/versi­ons/3.6.2/topics/help
  89. Shiny: Introduction to interactive documents
    https://shiny.rstudio.com/ar­ticles/interactive-docs.html
  90. R Release History 1997–2013
    http://timelyportfolio.git­hub.io/rCharts_timeline_r/
  91. R: atomic vectors
    https://renenyffenegger.ch/no­tes/development/languages/R/da­ta-structures/vector/
  92. 11 Best R Programming IDE and editors
    https://www.dunebook.com/best-r-programming-ide/
  93. CRAN – The Comprehensive R Archive Network
    https://cran.r-project.org/
  94. R – Arrays
    https://www.tutorialspoin­t.com/r/r_arrays.htm
  95. Array vs Matrix in R Programming
    https://www.geeksforgeeks.org/array-vs-matrix-in-r-programming/?ref=rp
  96. Online R Language IDE
    https://www.jdoodle.com/execute-r-online/
  97. Execute R Online (R v3.4.1)
    https://www.tutorialspoin­t.com/execute_r_online.php
  98. Snippets: Run any R code you like. There are over twelve thousand R packages preloaded
    https://rdrr.io/snippets/
  99. R Package Documentation
    https://rdrr.io/
  100. Data Reshaping in R – Popular Functions to Organise Data
    https://techvidvan.com/tutorials/data-reshaping-in-r/
  101. What is an R Data Frame?
    https://magoosh.com/data-science/what-is-an-r-data-frame/
  102. What's a data frame?
    https://campus.datacamp.com/cou­rses/free-introduction-to-r/chapter-5-data-frames?ex=1
  103. data.frame
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/data.frame
  104. as.data.frame
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/as.data.fra­me
  105. table
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/table
  106. Python Pandas – DataFrame
    https://www.tutorialspoin­t.com/python_pandas/python_pan­das_dataframe.htm
  107. The Pandas DataFrame: Make Working With Data Delightful
    https://realpython.com/pandas-dataframe/
  108. Python | Pandas DataFrame
    https://www.geeksforgeeks.org/python-pandas-dataframe/
  109. R – Factors
    https://www.tutorialspoin­t.com/r/r_factors.htm
  110. R – Scatterplots
    https://www.tutorialspoin­t.com/r/r_scatterplots.htm
  111. Quick guide to line types (lty) in R
    https://www.benjaminbell.co­.uk/2018/02/quick-guide-to-line-types-lty-in-r.html
  112. Lattice C (Wikipedia)
    https://en.wikipedia.org/wi­ki/Lattice_C
  113. Lorenz Attractor in R
    https://www.sixhat.net/lorenz-attractor-in-r.html
  114. Small multiple
    https://en.wikipedia.org/wi­ki/Small_multiple
  115. Category:Infographics (infografika)
    https://en.wikipedia.org/wi­ki/Category:Infographics
  116. Trellis plots (pro Python)
    https://subscription.packtpub­.com/book/big_data_and_bu­siness_intelligence/9781784390150/4/ch04l­vl1sec41/trellis-plots
  117. Trellis (architecture)
    https://en.wikipedia.org/wi­ki/Trellis_(architecture)
  118. Izobara (meteorologie)
    https://cs.wikipedia.org/wi­ki/Izobara_(meteorologie)
  119. How to Create a Lattice Plot in R
    https://www.dummies.com/pro­gramming/r/how-to-create-a-lattice-plot-in-r/
  120. Density estimation
    https://en.wikipedia.org/wi­ki/Density_estimation
  121. Sedm smrtelných statistických hříchů
    http://dfens-cz.com/sedm-smrtelnych-statistickych-hrichu/
  122. Spurious correlations
    https://tylervigen.com/spurious-correlations
  123. R programming
    https://www.slideshare.net/shan­tanupatil104/r-programming-44637606
  124. R language tutorial
    https://www.slideshare.net/ChiuYW/r-language-tutorial
  125. An Interactive Introduction To R (Programming Language For Statistics)
    https://www.slideshare.net/da­taspora/an-interactive-introduction-to-r-programming-language-for-statistics
  126. A Pamphlet against R
    https://panicz.github.io/pamphlet/
  127. Notebook interface
    https://en.wikipedia.org/wi­ki/Notebook_interface
  128. Jypyter: open source, interactive data science and scientific computing across over 40 programming languages
    https://jupyter.org/
  129. nbviewer: a simple way to share Jupyter Notebooks
    https://nbviewer.jupyter.org/
  130. Video streaming in the Jupyter Notebook
    https://towardsdatascience.com/video-streaming-in-the-jupyter-notebook-635bc5809e85
  131. How IPython and Jupyter Notebook work
    https://jupyter.readthedoc­s.io/en/latest/architectu­re/how_jupyter_ipython_wor­k.html
  132. Jupyter kernels
    https://github.com/jupyter/ju­pyter/wiki/Jupyter-kernels
  133. PNG is Not GIF
    https://www.root.cz/clanky/png-is-not-gif/
  134. Anatomie grafického formátu PNG
    https://www.root.cz/clanky/anatomie-grafickeho-formatu-png/
  135. PNG – bity, byty, chunky
    https://www.root.cz/clanky/png-bity-byty-chunky/
  136. Řádkové filtry v PNG
    https://www.root.cz/clanky/radkove-filtry-v-png/
  137. Nepovinné chunky v PNG a kontrola pomocí CRC
    https://www.root.cz/clanky/nepovinne-chunky-v-png-a-kontrola-pomoci-crc/

Autor článku

Pavel Tišnovský vystudoval VUT FIT a v současné době pracuje ve společnosti Red Hat, kde vyvíjí nástroje pro OpenShift.io.