02_uvod_do_R_2.qmd

# Opakovaní R

::: callout-warning
## Cíle cvičení

-   Umět vyhledat nápovědu k funkci.
-   Ovládat základní matematické výpočty pmocí funkcí a operátorů.
-   Umět definovat objekt v datovém typy a struktuře a tyto vzájemně transoformovat.
-   Ovládat běh výpočtu pomocí podmínek a cyků.
-   Přidávat k pracovnímu postupu vlastní funkce.
:::

Základy jazyka jsou vyučovány již v prvním semestru studia Vodního hospodářství. Na tomto místě je pouze zhuštěný přehled funkcionality z uvedeného kurzu.

## Nápověda

Zadává se do konzole ve tvaru `help(<jméno funkce>)`, nebo `<jmeno funkce>`. Pokud bychom se chtěli podívat přímo do kódu funkce, také je to možné, jméno funkce pouze vepíšeme do konzole bez závorek, případně použijeme příkazu `View(<jmeno funkce>)`. Kromě toho existuje v R také `help.search(<jméno funkce>)` pod zkratkou `??`, jež hledá fulltextovou nápovědu napříč nainstalovanými balíčky. Dále je ještě možné prohledat mailing list jazyka R pomocí funkce `RSiteSearch()`, která otevře nové okno předdefinovaného prohlížeče. Dále jsou velmi užitečné tematicky ucelené karty nápověd: `?Logical`, `?Constants`, `?Control`, `?Arithmetic`, `?Syntax`, `?Special` a další.


::: callout-tip
## Úloha

1.  Vyhledejte nápovědu k `DateTimeClasses`.\
    a)  Co reprezentují třídy `POSIXct` a `POSIXlt`?\
    b)  Jaký je mezi nimi rozdíl?\
    c)  Nalezněte funkci pro výpočet $5!$\
:::

## Jmenné konvence

Objekty, které vznikají při práci s R musí splňovat následující jmenné konvence. Název objektu nelze začínat číslovkou nebo operátorem, nesmít být totžný s žádným klíčovým slovem, obsahovat mezeru.

##### Klíčová slova {.unnumbered}

`if`, `else`, `repeat`, `while`, `function`, `for`, `in`, `next`, `repeat`, `break`, `TRUE`, `FALSE`, `NULL`, `Inf`, `NaN`, `NA`, `NA_integer_`, `NA_real_`, `NA_complex_`, `NA_character_`, a speciální znak: `_`

Nedoporučuje se vkládat do názvu proměnné tečku, např. `morava.prutoky`, a pojmenovávat shodně s běžně používanou funkcí. R je "case-sensitive" jazyk tzn., že proměnná `X` se nerovná `x`.

::: callout-tip
## Úloha

2.  Intuitivně by nás mohlo vést nahrát data do proměnné `data`. Je to chybný postup, neboť `data()` je funkce zpřístupňující datové sady, kterou jsou součástí instalace. Vyzkoušejte.
:::

##### Příklady nevhodných proměnných {.unnumbered}

`aaa`, `Morávka průtok [m/s]`, `moje.proměnná`\
Žádné z těchto jmen proměnných není proti

## Uvozovky a závorky

Představují párové znaky jazyka R. Závorky se používají trojího typu: kulaté, hranaté a složené a všechny mají jasně vymezné pole působnosti.

-   `()` **se používají vždy se jménem funkce** a uvozují prostor ve kterém se parametrizují argumenty funkce.\
-   `[]` se **vždy pojí se jménem objektu** (vektoru, pole, listu, ...) a vymezují výběr z daného objektu.\
-   `{}` **ohraničují blok kódu**, který se má vykonat v celku.\

Uvozovky uvozují textové řetězce. Lze používat jak dvojté `"` tak jednoduché `'` uvozovky zcela zástupně, je pouze třeba uzavírat shodným typem. Hojně se lze setkat se zpětnými uvozovkami, které se například použijí pro ohraničení nestandardního názvu sloupce ve struktuře.

```{r,eval=FALSE}
"Správně"
"Špatně'

```

::: callout-tip
## Úloha

3.  Zadejte špatnou variantu z kódu výše do konzole a sledujte chování prostředí. Co vyjadřuje znak `+`?
:::

## Operátory

Rozlišujeme operátory aritmetické, relační, přiřazení a patří sem i množinové funkce.

| Znak                                                        | Význam                                                                                                               |
|--------------------------------|----------------------------------------|
| `+` , `-` , `*` , `/` , `%%` , `%/%` , `**` nebo `^`, `%*%` | aritmetické operátory (sčítání, odčítání, násobení, dělení, modulo, celočíselné dělení, mocnění a maticové násobení) |
| `>` ,`>=` , `<` , `<=` , `==` , `!=`                        | relační operátory (větší/menžší než, rovno, nerovno)                                                                 |
| `!` , `&` , `&&` , `|` , `||`                               | logické (ne, a soužasně, zdvojené po prvcích vektoru)                                                                |
| `~`                                                         | zadání funkčního vztahu                                                                                              |
| `<-` , `=`, `<<-`, `->`                                     | operátory přiřazení                                                                                                  |
| `$`                                                         | jmenný index v heterogenních strukturách                                                                             |
| `:`                                                         | rozsah                                                                                                               |
| `isTRUE()` , `all()` , `any()` , `%in%` , `setdiff()`       | množinové funkce                                                                                                     |

```{r, eval = FALSE, collapse = TRUE}

xor(x)    # <11>
isTRUE(x) # <12>
any() # <13>
all() # <14>
%in% # <15>
setdiff(x, y)  # <16>
```

1.  Menší než
2.  Větší než
3.  Větší nebo rovno
4.  Menší nebo rovno
5.  Rovno
6.  Nerovno
7.  Logické "a"
8.  Logické "a" přes vektor
9.  Logické "nebo"\
10. Logické "nebo" přes vektor
11. Negace
12. Je $x$ "pravda"?
13. Je něco z obsahu "pravda"?
14. Je vše z obsahu "pravda"?
15. Je něco obsaženo v?
16. Chybí něco něco z obsahu v?

::: callout-tip
## Úloha

4.  Použite k výpočtu operátory či množinové funkce:\
    a)  Zjistěte, zda je číslo 1109388 dělitelné 7.\
    b)  Do vektoru $\mathbf{\mathrm{a}}$ uložte násobky 3 v rozsahu $\langle-121;30\rangle$ a $\mathbf{\mathrm{b}}$ násobky 7 v rozmezí\
    c)  Vypište hodnoty\
:::

## Matematické funkce

| Funkce                            | Význam                                                                                                                                                                                                                                      |
|------------------------|------------------------------------------------|
| `log(x)`                          | logaritmus $x$ o základu $e$                                                                                                                                                                                                                |
| `exp(x)`                          | odlogaritmování $x(e^x)$                                                                                                                                                                                                                    |
| `log(x, n)`                       | logaritmus $x$ o základu $n$                                                                                                                                                                                                                |
| `log10(x)`                        | logaritmus $x$ o základu $10$                                                                                                                                                                                                               |
| `sqrt(x)`                         | druhá odmocnina z $x$                                                                                                                                                                                                                       |
| `factorial`(x)                    | $x!$                                                                                                                                                                                                                                        |
| `choose(n, x)`                    | binomické koeficienty $$                                                                                                                                                                                                                    
                                                                                                                                                                                                                                  \binom{n}{k} = \frac{n!}{k!(n-k)!}              
                                                                                                                                                                                                                               $$                                                 |
| `ceiling(x)`                      | nejmenší celé číslo větší než $x$                                                                                                                                                                                                           |
| `floor(x)`                        | největší celé číslo před $x$                                                                                                                                                                                                                |
| `trunc(x)`                        | nejbliřší celé číslo mez i$x$ a 0                                                                                                                                                                                                           |
| `round(x, digits)`                | zaokrouhlení $x$ na $n$ desetinných míst                                                                                                                                                                                                    |
| `signif(x, digits)`               | zaokrouhlení na počet platných číslic                                                                                                                                                                                                       |
| `cos(x)` , `sin(x)` , `tan(x)`    | funkce kosinus, sinus, tangens v radianech                                                                                                                                                                                                  |
| `acos(x)` , `asin(x)` , `atan(x)` | inverzní trigonometrické funkce                                                                                                                                                                                                             |
| `abs(x)`                          | absolutní hodnota                                                                                                                                                                                                                           |

::: callout-tip
## Úloha

5.  Vyhodnoťte s pomocí R následující výrazy:\
    a)  $1 + 3 \cdot (2 / 3)\:\mathrm{mod}\:3=$  `r fitb(answer = 3)`\
    b)  $\dfrac{\sin(2.3)}{\cos(\pi)}=$  `r fitb(answer = -0.7457052)`\
    c)  $\sum\limits_{i = 1}^{53}i=$ `r fitb(answer = 1431)`\
    d)  $\dfrac{-\infty}{0}=$ `r fitb(-Inf)`, $\dfrac{-\infty}{\infty}=$ `r fitb(NaN)`, $\dfrac{0}{0}=$ `r fitb(NaN)`\
    e)  $\left(\dfrac{2}{35}\right)^{0.5} \cdot 3 \cdot (2 / 3)=$ `r fitb(0.4780914)`\
    f)  $20!=$ `r fitb(2.432902e+18)`\
    g)  $\int_{0}^{3\pi} \sin(x) dx=$ `r fitb(c(2, "2 with absolute error < 1.7e-12"))`\
    h)  $\sqrt[3]{561}=$ `r fitb(8.247474)`\
    i)  $\mathrm{diag}\left( \pmatrix{5\\ 3}\cdot \pmatrix{6 & 5}\right)=$ `r fitb(c("30 15", "30, 15"))`\
    j)  $y=x^2 + 3\sqrt{x};\:y^\prime=$ `r fitb("2 * x + x^((3/2) - 1) * (3/2)")`
:::

## Datové typy

Tvoří prvky struktur. R je dynamicky typovaný jazyk, nepožaduje před zavedením proměnné její deklaraci.

|               | logical      | integer                | numeric                | complex                | character   |
|------------|------------|------------|------------|------------|------------|
| **logical**   | `logical`    | `integer`              | `numeric`              | `complex`              | `character` |
| **integer**   | `logical`    | `integer`              | `numeric`              | `complex`              | `character` |
| **numeric**   | `logical`    | `numeric`              | `numeric`              | `complex`              | `character` |
| **complex**   | `logical`    | `integer` + warning    | `numeric` + warning    | `complex`              | `character` |
| **character** | `NA_logical` | `NA_integer` + warning | `NA_numeric` + warning | `NA_complex` + warning | `character` |

: Základní datové typy a nucené převody mezi nimi.

K datovým typům (třídám) se pojí funkce `is.___` a `as.___` kteří slouží k dotazování na typ, resp. jeho nucenou změnu a dále funkce `class()`, `mode()` .

```{r}
is.character("ABC")
as.integer(11 + 1i)
```

Chybějící záznamy a speciální numerické případy `NA`, `NaN`, `NULL`, `Inf`, `-Inf` jsou hodnoty, které mohou vzniknout například jako výsledek početního úkonu, nebo špatného importu dat. Výraz `NA` je tvořen v datovém typu `logical`, nejméně náročném na paměť. Jinak je možné specifikovat chybějící hodnotu ve všech ostatních datových typech `NA_real_` (odpovídá double), `NA_integer_`, `NA_complex_` a `NA_character_`, které je vhodné využít zejména při vytváření datového rámce s přesně zadaným typem sloupců. `NULL` je návratová hodnota mnoha funkcí a výrazů, reprezentuje prázdný objekt. Výsledky `NaN` a `±Inf` pochází z aritmetických operací $\dfrac{1}{0}$ resp. $\dfrac{\pm0}{1}$ . `na.omit()`, `is.na()`, `complete.cases()`.

## Základní datové struktury

Základní datové struktury rozlišujeme na atomické (homogenní) a heterogenní datové struktury.

### Homogenní datové struktury

Homogenní datové struktury obsahují atomické vektory, faktory, matice a pole. Název je odvozen od jejich omezení v podvýběru obsahovat pouze typ sebe sama tzn. podvýběr matice může být opět pouze matice.

#### Atomický vektor `vector`

Vektor je v jazyce R základní stavební strukturou, nic jaká skalární veličina zde není. Koncept vektoru je zde chápán v matematickém smyslu jako jednosloupcová matice $\boldsymbol{\mathrm{A}} = (a_{ij})_{m1}$ hodnot.

$$
\mathbf{\mathrm{u}} = 
\begin{pmatrix}
1\\
1.5\\
-14\\
7.223\\
\end{pmatrix}, \qquad
\mathbf{\mathrm{v}} = 
\begin{pmatrix}
\mathrm{TRUE}\\
\mathrm{FALSE}\\
\mathrm{TRUE}\\
\mathrm{TRUE}\\
\end{pmatrix}, \qquad
\mathbf{\mathrm{u^T}} =
\begin{pmatrix}
1 & 1.5 & -14 & 7.233\\
\end{pmatrix}
$$

Může nabývat jakéhokoliv datového typu, nicméně všechny prvky v daném vektoru jsou právě jednoho typu, čímž rozumíme, že je tato struktura tzv. homogenní. Vektor je možné vytvořit mnoha způsoby, mezi nejčastější patří funkce `vector(mode = "numeric", length = 10)` a funkce `c()`, případně vzniká pomocí opetárorů `[` nebo `[[`.

S vektory se pojí důležité pravidlo - **recyklace hodnot**.

```{r}
v <- c(1.4, 2.0, 6.1, 2.7)
u <- c(2.0, 1.3)
u + v # <1> 
u * v # <2> 
u * 2.3 # <3> 
```

1.  Sčítám vektory přičemž délka jednoho je násobkem délky druhého.
2.  Násobím vektory přičemž délka jednoho je násobkem délky druhého.
3.  Násobení vektoru číslenou hodnotou

##### Práce s vektory {.unnumbered}

```{r}
x <- 1:10 #<1>
x <- seq(10:1) #<1>
x <- vector(mode = "numeric", length = 10) #<1>
x <- replicate(n = 10, expr = eval(2)) #<1>
x <- sample(x = 10, size = 10, replace = TRUE) #<1>
x <- rep(x = 15, times = 2) #<1>
x <- rnorm(n = 10, mean = 2, sd = 20) #<1>
t(x) * x #<2> 
names(x) <- LETTERS[1:length(x)] #<3>
x[x > 0] #<4> 
x[1:3] #<5> 
```

1.  Tvorba vektoru $\boldsymbol{\mathrm{x}}$ různými úkony. Použití sekvence, repetice, opakování a vzorkování.
2.  Transpozice vektoru.
3.  Pojmenování pozic ve vektoru
4.  Výběr hodnot z vektoru na základě podmínky
5.  Výběr hodnot z vektoru na základě pozice

::: callout-tip
## Úloha

6.  

    a)  Vytvořte libovolným způsobem vektor `x` 10 různých číselných hodnot, kde $x\in\mathbb{R}$.
    b)  Zapište výraz pro výběr čísel v rozmezí -5 a 5 z tohoto vektoru.
    c)  Proveďte převod na celočíselný typ a diskutujte výsledek.
    d)  Přidejte k vektoru 3 pozice "A", "B" a "C", změnil se vektor?
:::

#### Faktor

Faktorem rozumíme kategorickou proměnnou, která je určena výčtem hodnot. Ukážeme si na příkladu "tříd přesnosti měření".

```{r}

trida <- factor(x = 1:4,
                labels = c(paste(1:4, ". třída", sep = "")), 
                ordered = TRUE)

```

#### Matice `matrix`

Rozšířením rozměrů vektoru vznikne matice nebo obecně pole.

```{r}
x <- c(1:10)
dim(x) <- c(2, 5) #<1>
x
```

1.  Převod na rozměr $2\times 2$

| Funkce            | Úkon                                   |
|-------------------|----------------------------------------|
| `nrow()`, `ncol()` | počet řádků, sloupců matice            |
| `dim()`           | řádky $\times$ sloupce matice          |
| `det()`           | deteminant matice                      |
| `eigen()`         | vlastní čísla a vlastní vektory matice |
| `colnames()`      | jména sloupců v matici                 |
| `rowSums()`       | řádkové součty matice                  |
| `colMeans()`      | sloupcové průměry matice               |
| `M[m, ]`          | Výběr $m$-tého řádku matice            |
| `M[ ,n]`          | Výběr $n$-tého sloupce matice          |

Stejně jako u vektoru opět platí typová homogenita

```{r}
B <- matrix(
  data = c(1, 2 + 3i, 5.4, 4, 5), 
  nrow = 2, 
  ncol = 3)
```

```{r, collapse=TRUE}
A <- matrix(data = seq(from = 1, to = 16, by = 2), nrow = 4)
str(A) # <1> 
dim(A) # <2> 
svd(A) # <3> 
diag(A) # <4> 
# sweep(x = A, MARGIN = 1, STATS = mean)
```

1.  Struktura objektu
2.  Dimenze matice
3.  Singulární rozklad
4.  Prvky na diagonále matice

::: callout-tip
## Úloha

7.  a)  S pomocí nápovědy k funkci `rnorm()` vytvořte matici $\boldsymbol{\mathrm{M}}; h(\boldsymbol{\mathrm{M}}) = 8$ náhodných čísel.
    b)  Vytvořte vektor hodnot od $100$ do $1$ sestupně, využijte nápovědu k funkci `seq()`.\
    c)  Spočtěte rozdíl, matic $\boldsymbol{\mathrm{A}}$, $\boldsymbol{\mathrm{B}}$. $$\boldsymbol{\mathrm{A}} = \left(
          \begin{matrix}
          2 & 2 & 5\\
          9 & 2 & 7\\
          1 & 3 & 18\\
          \end{matrix}
          \right),\qquad 
          \boldsymbol{\mathrm{B}} = \left(
          \begin{matrix}
          5 & 4 & 5\\
          -7 & 2 & 4\\
          10 & 1 & 5\\
          \end{matrix}
          \right)
          $$\
    d)  Spočítejte inverzní matici k matici $\boldsymbol{\mathrm{A}}$. Najděte vhodnou funkci s pomocí nápovědy.\
    e)  S pomocí hodnot `TRUE`/`FALSE` vytvořte matici $\boldsymbol{\mathrm{M}}(3,3)$, změňte typ prvku na pozici $\boldsymbol{\mathrm{M}}[1, 1]$ na textový řetězec. Ovlivní tato změna ostatní prvky v matici?\
    f)  Vyřešte s pomocí R soustavu lineárních rovnic:
    $$\begin{array}
      -3x & +2y& +z&=1\\
      -2x & -y& +z&=2\\
      2x & +y& -4z&=0
      \end{array}
    $$
:::

````{=html}
<!-- 
```{r include=FALSE}
Sys.setenv(LIBGS = "/usr/local/share/ghostscript/10.03.0/lib/")
font_opts <- list(dvisvgm.opts = "--font-format=woff")
```

```{tikz, engine.opts=font_opts}
#| echo: false
#| fig-cap: "N-dimenzionální pole"
#| fig-align: center
#| out-width: 30%
\usetikzlibrary{matrix}
\begin{tikzpicture}[auto matrix/.style={matrix of nodes,
  draw,thick,inner sep=0pt,
  nodes in empty cells,column sep=-0.2pt,row sep=-0.2pt,
  cells={nodes={minimum width=1.9em,minimum height=1.9em,
   draw,very thin,anchor=center,fill=white,
   execute at begin node={%
   $\vphantom{x_|}\ifnum\the\pgfmatrixcurrentrow<4
     \ifnum\the\pgfmatrixcurrentcolumn<4
      {#1}^{\the\pgfmatrixcurrentrow}_{\the\pgfmatrixcurrentcolumn}
     \else 
      \ifnum\the\pgfmatrixcurrentcolumn=5
       {#1}^{\the\pgfmatrixcurrentrow}_{N}
      \fi
     \fi
    \else
     \ifnum\the\pgfmatrixcurrentrow=5
      \ifnum\the\pgfmatrixcurrentcolumn<4
       {#1}^{T}_{\the\pgfmatrixcurrentcolumn}
      \else
       \ifnum\the\pgfmatrixcurrentcolumn=5
        {#1}^{T}_{N}
       \fi 
      \fi
     \fi
    \fi  
    \ifnum\the\pgfmatrixcurrentrow\the\pgfmatrixcurrentcolumn=14
     \cdots
    \fi
    \ifnum\the\pgfmatrixcurrentrow\the\pgfmatrixcurrentcolumn=41
     \vdots
    \fi
    \ifnum\the\pgfmatrixcurrentrow\the\pgfmatrixcurrentcolumn=44
     \ddots
    \fi$
    }
  }}}]
 \matrix[auto matrix=z,xshift=3em,yshift=3em](matz){
  & & & & \\
  & & & & \\
  & & & & \\
  & & & & \\
  & & & & \\
 };
 \matrix[auto matrix=y,xshift=1.5em,yshift=1.5em](maty){
  & & & & \\
  & & & & \\
  & & & & \\
  & & & & \\
  & & & & \\
 };
 \matrix[auto matrix=x](matx){
  & & & & \\
  & & & & \\
  & & & & \\
  & & & & \\
  & & & & \\
 };
 \draw[thick,-stealth] ([xshift=1ex]matx.south east) -- ([xshift=1ex]matz.south east)
  node[midway,below,rotate=45] {dimenze};
 \draw[thick,-stealth] ([yshift=-1ex]matx.south west) -- 
  ([yshift=-1ex]matx.south east) node[midway,below] {sloupce};
 \draw[thick,-stealth] ([xshift=-1ex]matx.north west)
   -- ([xshift=-1ex]matx.south west) node[midway,above,rotate=90] {řádky};
\end{tikzpicture}
```
-->
````

### Heterogenní datové struktury

Za **rúznorodé** struktury se označují ty, které mohou uchovávat dva a více prvků rozdílného typu současně. Z těch základních to jsou `data.frame` a `list`, dále pak `S4`, nebo `R6` třídy, případně další uživatelem vytvořené struktury.

#### Datová tabulka `data.frame`

`data.frame` je *de facto* vektor stejně dlouhých vektorů, které kromě toho, že musí být shodné délky, mohou být vzájmeně rozdílného datového typu.

```{r, eval=TRUE, collapse=TRUE}
DF <- data.frame(name = letters[1:5], 
                 value = rnorm(5))
DF
DF["name"]        # podvýběr do data.frame
DF[["name"]]      # podvýběr do vektoru
DF[, "name"]      # podvýběr do vektoru
```

Práce uvnitř `data.frame`

```{r, eval=TRUE, collapse=TRUE}
DF <- data.frame(
  mon = rep(month.abb, 
            times = c(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)), 
  value = rnorm(365), 
  yr = 2001)
str(DF)
names(DF)
nrow(DF)
ncol(DF)
```

## Řídící struktury

Zajišťují obecný průběh programu, tvoří základní prvky algoritmů. Mezi řídící strukury řadíme podmínky a cykly. Mohli bychom přidat i složené závorky, něboť pro struktury uvozují bloky kódu.

### Podmínky

#### `if()`

```{r}
A <- 1
if(A >= 1) {
  cat("A je větší nebo shodné s 1.")
}
```

```{r}
A <- 5
if(A >= 2) { #<1>
  cat("A je větší nebo shodné s 2.") #<1>
} else if(A > 2) { #<1>
  cat("A je větší než 2.") #<1>
} #<1>
```

1.  Řetěz podmínek se uzavře **v momentě, kdy je výraz v závorce poprvé vyhodnocen jako pravdivý**.

#### `ifelse()`

Vektorizovaný tvar podmínky, který lze volat na prvky struktur.

```{r}
x <- -5:5
cat("Prvek x + 3 je více než 0: ", ifelse(x - 3 > 0, yes = "Ano", no = "Ne"))
```

#### `switch()`

```{r}
varianta <- "B"
2 * (switch(
      varianta,
        "A" = 2,  # <1> 
        "B" = 3)) # <2> 
```

1.  Varianta "A nenastala,
2.  nastala varianta "B", tzn. výraz je vyhodnocen ve tvaru $2\cdot 3 = 6$


::: callout-tip
## Úloha

8.  a)  Vytvořte s pomocí podmínek známkovací schéma:

| Známka  | Rozmezí     |  
|---------|-------------|
| 1       | 90 - 100 \% | 
| 2       | 75 - 89 \%  | 
| 3       | 60 - 74 \%  | 
| 4       |  < 60 \%    |
:::


### Cykly

Zajištují, že se část kódu provede opakovaně.

#### `for()` z definovaného rozsahu

Pokud je předem znám počet opakování cyklu (nebo je i jinak implicitně určen), používá se `for` cyklu.

```{r}
for(i in 1:4) {
  cat("Iterace ", i, "\n")
}
```

#### `while()` s pomocí podmínky

V případech, kdy počet opakování není předem znám, ale je známa podmínka, za které cyklus má probíhat.

```{r}
i <- 1
while(i < 5) {
  cat("Iterace ", i, "\n")
  i <- i + 1
}
```

#### `repeat` s únikovou sekvencí

Počet opakování neni předem znám. Nicméně lze definovat případ, kdy má cyklus skončit.

```{r}
i <- 1
repeat { #<1>
  cat("Iterace ", i, "\n") #<1>
  i <- i + 1 #<1>
  if(i >= 5) break #<1> # <2>
} #<1>
```

1.  Prováděj
2.  Vnořenou podmínkou následovanou klíčovým slovem `break` definujeme konec cyklu.

Kromě únikového klíčového slova `break` po němž cyklus okamžitě skončí je k využití příkaz `next`, po němž se zbytek příkazů v dané iteraci přeskočí a operátor `%||%`.

::: callout-tip
## Úloha

8.  a) Vytvořte cyklus, který pro čísla $1, 2, 3, 4, 5$ vypíše jejich třetí mocniny
    b) Pro stejná čísla provede kumulativní součet.
    c) Pro číslo `n` provede výpočet faktorialu.
    d) S pomocí funkce `readline()` od uživatele požaduje číslo, které vždy vypíše.
       Pokud je číslo záporné, skončí smyčku.
:::

## Vlastní funkce

K funkce slouží klíčové slovo `function`, které v závorkách doprovází argumenty sloužící k vnitřní specifikaci funkce.

```{r}
x <- rnorm(100)
nejblizsi_hodnota <- function(x, value) { # <1>
  x[which(abs(x - value) == min(abs(x - value)))] # <1>
} # <1>

cat("Hodnota nejblíže 0 z vektoru x je:" , 
    nejblizsi_hodnota(x = x, value = 0))
```

1.  Příklad funkce, která vyhledá nejbližší z hodnot vektoru `x` k referenční hodnotě `value`.


## Rekapitulace

Vyplňte následující formulář bez použití R.\

```{r, include=FALSE}
opts1 <- c("Počet sloupců i řádků musí být shodný", 
           answer = "Proměnnná musí mít uvedenou hodnotu v každém řádku", 
           "Všechny proměnné musí být stejného typu")
opts2 <- c("Počet sloupců i řádků musí být shodný", 
           "Proměnnná musí mít uvedenou hodnotu v každém řádku", 
           "Všechny proměnné musí být stejného typu", 
           answer = "Je možné do něj rekurzivně vniřit další objekt typu list")
```

  1. Zvolte platné tvrzení pro `data.frame`: `r longmcq(opts = opts1)`
  2. Matici je možné vytvořit z vektoru přidáním dimenze: `r torf(answer = TRUE)`\
  3. Co je výsledkem výrazu: $\sin(\frac{0}{0})$ `r fitb(answer = "NaN")`\
  4. Vyberte, platné tvrzení pro list: `r longmcq(opts = opts2)`
  5. Napište výraz pro nepřiřazenou číselnou hodnotu : `r fitb(answer = "NA_real_")`\
  6. Dolňte chybějící zápis cyklu: `r fitb(answer = "6-i")`\
  ```
    for(i in 1:5) {
      cat(___)    
    }
    > 54321
  ```