% Options for packages loaded elsewhere
\PassOptionsToPackage{unicode}{hyperref}
\PassOptionsToPackage{hyphens}{url}
%
\documentclass[
  10pt,
  a4paper]{memoir}
\usepackage{amsmath,amssymb}
\usepackage{lmodern}
\usepackage{ifxetex,ifluatex}
\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex
  \usepackage[T1]{fontenc}
  \usepackage[utf8]{inputenc}
  \usepackage{textcomp} % provide euro and other symbols
\else % if luatex or xetex
  \usepackage{unicode-math}
  \defaultfontfeatures{Scale=MatchLowercase}
  \defaultfontfeatures[\rmfamily]{Ligatures=TeX,Scale=1}
\fi
% Use upquote if available, for straight quotes in verbatim environments
\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
\IfFileExists{microtype.sty}{% use microtype if available
  \usepackage[]{microtype}
  \UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
}{}
\makeatletter
\@ifundefined{KOMAClassName}{% if non-KOMA class
  \IfFileExists{parskip.sty}{%
    \usepackage{parskip}
  }{% else
    \setlength{\parindent}{0pt}
    \setlength{\parskip}{6pt plus 2pt minus 1pt}}
}{% if KOMA class
  \KOMAoptions{parskip=half}}
\makeatother
\usepackage{xcolor}
\IfFileExists{xurl.sty}{\usepackage{xurl}}{} % add URL line breaks if available
\IfFileExists{bookmark.sty}{\usepackage{bookmark}}{\usepackage{hyperref}}
\hypersetup{
  pdftitle={Ekonometrie v R},
  pdfauthor={Štěpán Mikula},
  hidelinks,
  pdfcreator={LaTeX via pandoc}}
\urlstyle{same} % disable monospaced font for URLs
\usepackage{color}
\usepackage{fancyvrb}
\newcommand{\VerbBar}{|}
\newcommand{\VERB}{\Verb[commandchars=\\\{\}]}
\DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}}
% Add ',fontsize=\small' for more characters per line
\usepackage{framed}
\definecolor{shadecolor}{RGB}{248,248,248}
\newenvironment{Shaded}{\begin{snugshade}}{\end{snugshade}}
\newcommand{\AlertTok}[1]{\textcolor[rgb]{0.94,0.16,0.16}{#1}}
\newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
\newcommand{\AttributeTok}[1]{\textcolor[rgb]{0.77,0.63,0.00}{#1}}
\newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
\newcommand{\BuiltInTok}[1]{#1}
\newcommand{\CharTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
\newcommand{\CommentTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textit{#1}}}
\newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
\newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
\newcommand{\ControlFlowTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{\textbf{#1}}}
\newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{#1}}
\newcommand{\DecValTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
\newcommand{\DocumentationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
\newcommand{\ErrorTok}[1]{\textcolor[rgb]{0.64,0.00,0.00}{\textbf{#1}}}
\newcommand{\ExtensionTok}[1]{#1}
\newcommand{\FloatTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
\newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
\newcommand{\ImportTok}[1]{#1}
\newcommand{\InformationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
\newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{\textbf{#1}}}
\newcommand{\NormalTok}[1]{#1}
\newcommand{\OperatorTok}[1]{\textcolor[rgb]{0.81,0.36,0.00}{\textbf{#1}}}
\newcommand{\OtherTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{#1}}
\newcommand{\PreprocessorTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textit{#1}}}
\newcommand{\RegionMarkerTok}[1]{#1}
\newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
\newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
\newcommand{\StringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
\newcommand{\VariableTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
\newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
\newcommand{\WarningTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
\usepackage{longtable,booktabs,array}
\usepackage{calc} % for calculating minipage widths
% Correct order of tables after \paragraph or \subparagraph
\usepackage{etoolbox}
\makeatletter
\patchcmd\longtable{\par}{\if@noskipsec\mbox{}\fi\par}{}{}
\makeatother
% Allow footnotes in longtable head/foot
\IfFileExists{footnotehyper.sty}{\usepackage{footnotehyper}}{\usepackage{footnote}}
\makesavenoteenv{longtable}
\usepackage{graphicx}
\makeatletter
\def\maxwidth{\ifdim\Gin@nat@width>\linewidth\linewidth\else\Gin@nat@width\fi}
\def\maxheight{\ifdim\Gin@nat@height>\textheight\textheight\else\Gin@nat@height\fi}
\makeatother
% Scale images if necessary, so that they will not overflow the page
% margins by default, and it is still possible to overwrite the defaults
% using explicit options in \includegraphics[width, height, ...]{}
\setkeys{Gin}{width=\maxwidth,height=\maxheight,keepaspectratio}
% Set default figure placement to htbp
\makeatletter
\def\fps@figure{htbp}
\makeatother
\setlength{\emergencystretch}{3em} % prevent overfull lines
\providecommand{\tightlist}{%
  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
\setcounter{secnumdepth}{5}
% czech stuff
% \usepackage[czech]{babel}  % conflict with stargazer
\usepackage{indentfirst}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
%
%
% fonts
\usepackage{charter}
\usepackage[charter]{mathdesign}
%\usepackage{utopia}
%\usepackage[utopia]{mathdesign}
%
% stuff from bookdown minimal example
\usepackage{booktabs}
\usepackage{amsthm}
\makeatletter
\def\thm@space@setup{%
  \thm@preskip=8pt plus 2pt minus 4pt
  \thm@postskip=\thm@preskip
}
\makeatother
%
%
% setting up heads
% -- chapter
%\usepackage{fourier} % or what ever
\usepackage[scaled=.92]{helvet}%. Sans serif - Helvetica
\usepackage{color,calc}
\newsavebox{\ChpNumBox}
\definecolor{ChapBlue}{rgb}{0.00,0.65,0.65}
\makeatletter
\newcommand*{\thickhrulefill}{%
\leavevmode\leaders\hrule height 1\p@ \hfill \kern \z@}
\newcommand*\BuildChpNum[2]{%
\begin{tabular}[t]{@{}c@{}}
\makebox[0pt][c]{#1\strut} \\[.5ex]
\colorbox{ChapBlue}{%
\rule[-7em]{0pt}{0pt}%
\rule{1ex}{0pt}\color{black}#2\strut
\rule{1ex}{0pt}}%
\end{tabular}}
\makechapterstyle{BlueBox}{%
\renewcommand{\chapnamefont}{\large\scshape}
\renewcommand{\chapnumfont}{\Large\bfseries}%\Huge\bfseries}
\renewcommand{\chaptitlefont}{\raggedright\Large\bfseries}%\Huge\bfseries}
\setlength{\beforechapskip}{0pt}%20pt}
\setlength{\midchapskip}{16pt}
\setlength{\afterchapskip}{26pt}%40pt}
\renewcommand{\printchaptername}{}
\renewcommand{\chapternamenum}{}
\renewcommand{\printchapternum}{%
\sbox{\ChpNumBox}{%
\BuildChpNum{}%\chapnamefont\@chapapp}%
{\chapnumfont\thechapter}}}
\renewcommand{\printchapternonum}{%
\sbox{\ChpNumBox}{%
\BuildChpNum{\chapnamefont\vphantom{\@chapapp}}%
{\chapnumfont\hphantom{\thechapter}}}}
\renewcommand{\afterchapternum}{}
\renewcommand{\printchaptertitle}[1]{%
\usebox{\ChpNumBox}\hfill
\parbox[t]{\hsize-\wd\ChpNumBox-1em}{%
\vspace{\midchapskip}%
\thickhrulefill\par
\chaptitlefont ##1\par}}%
}
\chapterstyle{BlueBox}%
% -- section and subsection
\renewcommand{\secheadstyle}{\large\bfseries}%
\renewcommand{\subsecheadstyle}{\bfseries}%
\setbeforesecskip{2\onelineskip \@minus .01\onelineskip}%
\setaftersecskip{0.5\onelineskip \@minus .01\onelineskip}%
\setbeforesubsecskip{1.5\onelineskip \@minus .01\onelineskip}%
\setaftersubsecskip{0.3\onelineskip \@minus .01\onelineskip}%
% \makeatletter
% \makeheadstyles{mysecs}{%
%   \renewcommand\thesection{\arabic{section}}%
%   \setsecnumformat{\csname the##1\endcsname.\quad}%
%   \setbeforesecskip{2\onelineskip \@minus .01\onelineskip}%
%   \setaftersecskip{1\onelineskip \@minus .01\onelineskip}%
%   \setsecheadstyle{\normalfont\raggedright\MakeUppercase}%
% }
% \makeatother
% \headstyles{mysecs}
%
%
%
\settypeblocksize{23.7cm}{15.92cm}{*} % vertical, horizontal, ratio
\setheadfoot{0pt}{3\onelineskip}
\setlrmargins{*}{*}{1} % left, right, ratio
\setlength{\headsep}{0pt}
\setulmargins{20.4mm}{*}{1} % upper, lower, ratio
\setlength{\columnsep}{2cm}
%\setlength{\footskip}{3\baselineskip}
\checkandfixthelayout
%
\nouppercaseheads
\makepagestyle{mystyle}
\makeevenhead{mystyle}{}{}{}
\makeoddhead{mystyle}{}{}{}
\makeevenfoot{mystyle}{\itshape\thepage}{}{\itshape\rightmark}
\makeoddfoot{mystyle}{\itshape\leftmark}{}{\itshape\thepage}
% \makepsmarks{mystyle}{\createmark{chapter}{left}{nonumber}{}{}}
% \makepsmarks{mystyle}{\createmark{section}{right}{nonumber}{}{}}
\makepsmarks{mystyle}{%
    \createmark{chapter}{left}{nonumber}{}{}%
    \createmark{section}{right}{nonumber}{}{}}
\pagestyle{mystyle}
%
%
% title page
\setlength{\droptitle}{0cm}
\renewcommand{\maketitlehooka}{%
\hbox to\hsize{\hss\includegraphics{figs/basics/RStudioScreenshot.png}\hss}%
\vskip1cm}%
\pretitle{\begin{flushleft}\Huge\bfseries}%
\posttitle{\par\end{flushleft}\vskip 0.5em}%
\preauthor{\begin{flushleft}\large\bfseries}%
\postauthor{\par\end{flushleft}\vskip 0.3em}%
\predate{\begin{flushleft}\large}%
\postdate{\par\end{flushleft}\vskip 0.2em}%
\renewcommand{\maketitlehookd}{%
  \thispagestyle{empty}
  \newpage
  \leavevmode\strut\par
  \thispagestyle{empty}
  \newpage}%
% \renewcommand{\maketitle}{%
% \vspace*{\droptitle}
% \maketitlehooka
% {\pretitle \title \posttitle}
% \maketitlehookb
% {\preauthor \author \postauthor}
% \maketitlehookc
% {\predate \date \postdate}
% \maketitlehookd
% \thispagestyle{title}
% }

% remove parindent
\setlength{\parindent}{0em}
\setlength{\parskip}{0.6em plus 0.2em minus 0.1em}
\ifluatex
  \usepackage{selnolig}  % disable illegal ligatures
\fi
\usepackage[]{natbib}
\bibliographystyle{apalike}

\title{Ekonometrie v R}
\author{Štěpán Mikula}
\date{2021-07-22}

\begin{document}
\maketitle

{
\setcounter{tocdepth}{1}
\tableofcontents
}
\hypertarget{pux159edmluva}{%
\chapter*{Předmluva}\label{pux159edmluva}}
\addcontentsline{toc}{chapter}{Předmluva}

Cílem této knihy je pomoci čtenářům naučit se provádět datovou analýzu v~jazyce~R. R~je volně šiřitelný software pro statistickou a výpočetní analýzu, jehož popularita v~současné době výrazně roste. R~se používá jak k~výzkumu v~univerzitním prostředí, tak v~komerčních firmách jako je Microsoft, Google, Facebook apod., viz 1.~kapitola knihy.

Jednotlivá témata jsme do knihy vybírali tak, aby splňovala dvě kritéria: 1)~aby čtenář po jejím přečtení dokázal prakticky připravit k~analýze téměř jakákoli data, prozkoumat je a vizualizovat bez potřeby čtení jakékoli další knihy a aby se naučil dost na to, aby mohl dál samostatně rozvíjet své znalosti z~volně dostupných zdrojů; 2)~zaměřili jsme se na techniky a znalosti, které sami nejčastěji používáme ve vlastním výzkumu.

Tomu odpovídá struktura knihy: V~její první části se naučíte základy jazyka~R (s~jasným zaměřením na datovou analýzu), a~to v~takové míře, abyste mohli sami ``programovat s~daty'' a učit se dále konkrétní datové analýze. Druhá část se soustřeďuje na získání dat. Zde se naučíte získat data z~celé řady zdrojů počínaje textovými soubory CSV přes data z~databází až po data získaná strojově z~webových stránek. Ve třetí části se naučíte transformovat data pomocí moderních nástrojů ze skupiny \textbf{tidyverse}, zejména převádět data do analyticky přívětivé podoby, filtrovat a sumarizovat dat a spojovat data z~různých zdrojů. Čtvrtá část se zaměřuje na vizualizaci dat. V~této části se naučíte prezentovat svá mnohorozměrná data přehledným a estetickým způsobem v~publikační kvalitě. Následující část se zabývá základy statistické a ekonometrické analýzy. V~poslední části se naučíte strojově generovat výzkumné zprávy a prezentace a automaticky aktualizovat tyto dokumenty v~případě, že se data změní.

V~celém textu klademe důraz na praktické zvládnutí probírané látky. Každá kapitola proto obsahuje velké množství příkladů. Většina pokročilejších kapitol zahrnuje i~větší případové studie. Po přečtení této knihy byste tedy měli být schopní sami provádět datovou analýzu a samostatně se učit další věci z~dokumentace příslušných balíků.

Text knihy není zcela lineární. Někdy v~příkladech používáme i~funkce a koncepty, kterou jsou důkladněji vysvětlené až v~pozdějších kapitolách. Tento přístup jsme zvolili záměrně ze stejného důvodu, z~jakého se tento přístup používá v~moderních učebnicích jazyků. Tento přístup jednak umožňuje už relativně brzy ukázat příklady skutečného využití probírané látky, jednak usnadňuje pochopení pokročilejších konceptů, protože budete mít správný pocit, že ``už jste to viděli''.
Předpokládáme také, že budete kromě této knihy číst i~dokumentaci jednotlivých funkcí. To nejen umožní ušetřit v~knize místo vynecháním některých méně podstatných detailů, ale zejména vás bude motivovat naučit se používat dokumentaci. Při vlastní praktické práci je schopnost efektivně používat dokumentaci neocenitelná.

\hypertarget{ochutnuxe1vka-muxedsto-uxfavodu}{%
\chapter{Ochutnávka místo úvodu}\label{ochutnuxe1vka-muxedsto-uxfavodu}}

Tato kniha vysvětluje, jak analyzovat a vizualizovat data ve výpočetním prostředí~R. R~je programovací jazyk a výpočetní prostředí (nejen) pro statistické výpočty a grafiku. Umožňuje dva režimy práce. Prvním je interaktivní režim, kdy zapíšete zvolené výrazy do konzole a R je okamžitě vyhodnotí a na obrazovku vypíše výsledky a vykreslí obrázky. Druhým režimem je psaní skriptů. Skripty jsou jednoduché programy, které je možné spouštět opakovaně na původních nebo i~modifikovaných datech.

R~je známé svou obecností (jde v~něm řešit téměř jakýkoli problém), množstvím funkcí (R~pokrývá téměř každé odvětví statistiky, ekonometrie a \emph{data science} vůbec) a schopností vytvářet prvotřídní grafy v~publikační kvalitě. Cenou za tuto obecnost a šíři je však rozsah a jistá složitost tohoto jazyka. O~R~se často říká, že má ``steep learning curve''. V~této knize začínáme jazyk~R vysvětlovat ``od podlahy''. To znamená, že několik prvních kapitol strávíme poměrně nudnými a složitými, ale zároveň velmi důležitými základy, a~k~zábavnějším věcem se dostaneme až po zvládnutí těchto základů. Nechceme však, aby vás tyto základy odradily. Proto jsme na samý začátek knihy zařadili tuto kapitolu.

Tato kapitola má dva cíle. Prvním je ukázat vám, že přes všechnu svoji složitost je R správná volba pro každého, kdo to myslí s~analýzou dat vážně. Druhým cílem je ukázat vám pár příkladů toho, co budete po přečtení této knihy umět, abyste se měli na co těšit. Stejně jako celá kniha, i~tato kapitola je vytvořená přímo v~jazyce~R, přesněji v~jeho nadstavbě R~Markdown, se kterým se seznámíte v~kapitole~\ref{kap:rmarkdown}.

\hypertarget{proux10d-pruxe1vux11b-r}{%
\section{Proč právě R}\label{proux10d-pruxe1vux11b-r}}

Existuje mnoho dobrých důvodů, proč k~analýze dat používat~R.
To ukazuje i~fakt, že R je nejpoužívanějším nástrojem v~\emph{data science}, jak ukazuje např.~studie, kterou v~roce 2015 provedl \emph{Rexer Analytics} (studie je dostupná na \url{https://goo.gl/UWcMCF}). Téměř 80~\% respondentů této studie uvedlo, že ve své analytické práci používají~R, z~toho téměř polovina jako hlavní analytický nástroj, viz obrázek~\ref{fig:appetizer-anal-tools1}. Studie také ukazuje, že používání R je na vzestupu, viz obrázek~\ref{fig:appetizer-rise-r}.
R používají jak výzkumníci na univerzitách, tak i~ve velkých komerčních firmách, mimo jiné v~Microsoftu, Facebooku, Googlu, Twitteru, Fordu, Uberu, John Deere, Firefoxu, The New York Times, The Human Rights Data Analysis Group a dalších firmách (podrobnosti, viz např.~ \url{https://goo.gl/oE4hjo} a \url{https://goo.gl/4d2ez2}; více se o~rozšíření R můžete dočíst také na \url{https://goo.gl/zKpMco}).

\begin{figure}
\includegraphics[width=6in]{figs/appetizer/rexer2017_anal_tools} \caption{Analytické nástroje nejvíce používané respondnety Rexer Analytics Survey v roce 2017; každý respondent mohl zaškrtnout více nástrojů Zdroj: Rexer Analytics: A Decade of Surveying Analytic Professionals: 2017 Survey Highlights.}\label{fig:appetizer-anal-tools1}
\end{figure}

Velké rozšíření užívání R mezi profesionály znamená, že R má velkou komunitu často velmi pokročilých uživatelů. Díky tomu je dostupné velké množství dobrých materiálů, ať už se jedná o~knihy, blogy, návody na webu, video tutoriály nebo kurzy na Courseře. Zároveň to znamená, že vždy najdete někoho, kdo je ochotný vám poradit.

\begin{figure}
\includegraphics[width=4.06in]{figs/appetizer/rexer2017_rise_r} \caption{Růst využití R v čase respondnety Rexer Analytics Survey v roce 2017. Zdroj: Rexer Analytics: A Decade of Surveying Analytic Professionals: 2017 Survey Highlights.}\label{fig:appetizer-rise-r}
\end{figure}

Dalším důsledkem existence velké a rostoucí komunity uživatelů je i to, že R obsahuje velké množství metod pro řešení téměř všech problémů v~různých oblastech statistiky, ekonometrie a data science. Většina těchto metod je distribuována formou balíků, které jsou uloženy na jednom z~centrálních repositářů. Růst počtu balíků na hlavním repositáři balíků pro~R ukazuje obrázek~\ref{fig:appetizer-r-pkgs}. Všechny toto nástroje jsou přitom přítomné v~jednom softwaru, takže už nemusíte používat jeden software na přípravu dat, jiný na jejich vizualizaci, jiný na ekonometrii, další na \emph{machine learning} atd.

\begin{figure}
\includegraphics[width=4.25in]{figs/appetizer/packages_on_cran_2019} \caption{Počet balíků na CRANu ukazuje strmý růst objemu analytických nástrojů v R. Zdroj: Sacha Epskamp: "Reproducibility and Replicability in a Fast-Paced Methodological World", Advances in Methods and Practices in Psychological Science, 2019.}\label{fig:appetizer-r-pkgs}
\end{figure}

R navíc obsahuje velmi mocný, ale relativně jednoduchý programovací jazyk, takže svoji analýzu můžete nejen provést interaktivně, ale i~uložit si ji do skriptu a svůj výpočet kdykoli zopakovat stisknutím jednoho tlačítka, a~to jak na původních, tak na nových nebo aktualizovaných datech. Díky tomu po vás může kdokoli vaši analýzu zopakovat, což je jedna ze zásad \emph{reproducible research}. Přitom můžete smíchat výpočet a text a vytvořit ``živé dokumenty'' (jak ostatně vznikla tato kniha).
Svoji práci můžete dále zautomatizovat tak, že si na často opakované úkoly vytvoříte vlastní funkci nebo skript. A~pokud vám nějaká metoda v~R chybí, můžete ji sami naprogramovat a případně i~sdílet s~ostatními ve formě nového balíku. (Ačkoli je R poněkud specializovaný programovací jazyk, RedMonk jej ve své analýze popularity programovacích jazyků umístil v~roce~2018 R na 12~místo mezi \emph{všemi} programovacími jazyky, viz~obrázek~\ref{fig:appetizer-r-redmonk}.)

\begin{figure}
\includegraphics[width=5.25in]{figs/appetizer/redmonk-2020-01-sipka} \caption{Oblíbenost programovacích jazyků měřená počtem projektů na vodorovné ose počtem tagů na serveru StackOverflow na svislé ose. Zdroj: RedMonk, 2020.}\label{fig:appetizer-r-redmonk}
\end{figure}

Poslední, ale nikoli nejméně významnou výhodou, je to, že R je volně šiřitelný software dostupný pro všechny hlavní operační systémy. To znamená, že jej budete mít k~dispozici vždy a všude~-- a~navíc zdarma.

Kromě výhod má R samozřejmě i~slabé stránky. Jednou z~nich je to, že R je jazyk specializovaný na analýzu dat, nikoli obecný programovací jazyk jako je např.~Python, C++ nebo Java. V~některých situacích se tedy může stát, že budete potřebovat i~nějaký další nástroj. Pro vlastní analýzu dat si však s~R naprosto vystačíte.

Často uváděným nedostatkem R je jeho rychlost. Tvrdívá se, že R je poměrně pomalý jazyk. Striktně vzato je to pravda (i~když se jeho výkon neustále zlepšuje), ve většině případů to však nevadí, protože funkce, které by v~R běžely pomalu, jsou dávno implementované v~C++ nebo případně Fortranu a běží rychlostí těchto jazyků, tj.~téměř rychlostí strojového kódu.

R také dokáže pracovat pouze s~daty, která má uložená v~operační paměti počítače. To je však zřídkakdy výrazné omezení. Např.~tabulka s~milionem pozorování o~50~proměnných bude mít typicky něco kolem 400~MB, takže se do operační paměti běžného počítače pohodlně vejde. R~navíc dokáže velmi dobře spolupracovat s~databázemi, a~tak omezení pamětí počítač hravě obejít.

Překvapivě asi největší nevýhodou R je tak to, že se jedná o~poměrně starý jazyk, který prošel dlouhým vývojem, přičemž se na jeho vývoji se podílely tisíce dobrovolníků bez výraznější centrální koordinace. To kromě dobrých vlastností zmíněných výše působí i~některé problémy. Názvy funkcí a jejich syntaxe jsou někdy nekonzistenční. Každou věc je možné udělat mnoha různými způsoby a k~řešení mnoha problémů existuje několik různých balíků funkcí, takže někdy strávíte nějaký čas rozhodováním, kterou cestu zvolit. Navíc je chování některých funkcí v~některých speciálních situacích nečekané, protože to kdysi někomu přišlo jako dobrý nápad. Naštěstí se v~poslední době většina těchto problémů řeší vznikem balíků ze skupiny \textbf{tidyverse}. V~této knize budeme většinu věcí, kde existuje \textbf{tidyverse} alternativa řešit právě funkcemi definovanými v~těchto balících.

\hypertarget{ochutnuxe1vka-pruxe1ce-s-daty}{%
\section{Ochutnávka práce s daty}\label{ochutnuxe1vka-pruxe1ce-s-daty}}

V~tomto oddíle začneme se slíbenou ochutnávkou toho, na co se můžete v~R těšit. Začneme práci s~daty. Nevadí, že nebudete rozumět všemu, co se v~této kapitole děje. Věnujte však pozornost tomu, jak jednoduše můžete dostat celkem složitý výsledek.

Jak se v~R zachází s~datovými soubory, si ukážeme na příkladu data setu \emph{diamonds}. Nejdříve načteme potřebné balíky pomocí funkce \texttt{library()} a následně i~vlastní data.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(dplyr)}
\FunctionTok{library}\NormalTok{(purrr)}
\FunctionTok{library}\NormalTok{(ggplot2)}
\FunctionTok{library}\NormalTok{(stargazer)}
\FunctionTok{data}\NormalTok{(}\StringTok{"diamonds"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Nejprve se na data podíváme. Data set obsahuje údaje o~53 940 diamantech. Pro každý diamant (řádek tabulky) data set uvádí váhu diamantu v~karátech, kvalitu jeho řezu (cit), jeho barvu (chlor), rozměry a cenu (proce). R~inteligentně vypíše jen několik prvních řádků tabulky.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 53,940 x 10
##    carat cut       color clarity depth table price     x     y     z
##    <dbl> <ord>     <ord> <ord>   <dbl> <dbl> <int> <dbl> <dbl> <dbl>
##  1  0.23 Ideal     E     SI2      61.5    55   326  3.95  3.98  2.43
##  2  0.21 Premium   E     SI1      59.8    61   326  3.89  3.84  2.31
##  3  0.23 Good      E     VS1      56.9    65   327  4.05  4.07  2.31
##  4  0.29 Premium   I     VS2      62.4    58   334  4.2   4.23  2.63
##  5  0.31 Good      J     SI2      63.3    58   335  4.34  4.35  2.75
##  6  0.24 Very Good J     VVS2     62.8    57   336  3.94  3.96  2.48
##  7  0.24 Very Good I     VVS1     62.3    57   336  3.95  3.98  2.47
##  8  0.26 Very Good H     SI1      61.9    55   337  4.07  4.11  2.53
##  9  0.22 Fair      E     VS2      65.1    61   337  3.87  3.78  2.49
## 10  0.23 Very Good H     VS1      59.4    61   338  4     4.05  2.39
## # ... with 53,930 more rows
\end{verbatim}

R umožňuje s~daty manipulovat velmi elegantně. Například se můžeme podívat na cenu a váhu u~nejlépe zbarvených kamenů. Následující kód nejprve z~data setu vyfiltruje kameny se správnou barvou, a~pak vybere zvolené sloupce:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{filter}\NormalTok{(color }\SpecialCharTok{==} \StringTok{"D"}\NormalTok{) }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{select}\NormalTok{(color, price, carat)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6,775 x 3
##    color price carat
##    <ord> <int> <dbl>
##  1 D       357  0.23
##  2 D       402  0.23
##  3 D       403  0.26
##  4 D       403  0.26
##  5 D       403  0.26
##  6 D       404  0.22
##  7 D       552  0.3 
##  8 D       552  0.3 
##  9 D       552  0.3 
## 10 D       553  0.24
## # ... with 6,765 more rows
\end{verbatim}

Data lze i~jednoduše řadit. Například je možné se podívat na ty nejdražší kameny. Následující kód setřídí kameny sestupně podle ceny (tj.~od nejvyšší po nejnižší cenu):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{arrange}\NormalTok{(}\FunctionTok{desc}\NormalTok{(price))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 53,940 x 10
##    carat cut       color clarity depth table price     x     y     z
##    <dbl> <ord>     <ord> <ord>   <dbl> <dbl> <int> <dbl> <dbl> <dbl>
##  1  2.29 Premium   I     VS2      60.8    60 18823  8.5   8.47  5.16
##  2  2    Very Good G     SI1      63.5    56 18818  7.9   7.97  5.04
##  3  1.51 Ideal     G     IF       61.7    55 18806  7.37  7.41  4.56
##  4  2.07 Ideal     G     SI2      62.5    55 18804  8.2   8.13  5.11
##  5  2    Very Good H     SI1      62.8    57 18803  7.95  8     5.01
##  6  2.29 Premium   I     SI1      61.8    59 18797  8.52  8.45  5.24
##  7  2.04 Premium   H     SI1      58.1    60 18795  8.37  8.28  4.84
##  8  2    Premium   I     VS1      60.8    59 18795  8.13  8.02  4.91
##  9  1.71 Premium   F     VS2      62.3    59 18791  7.57  7.53  4.7 
## 10  2.15 Ideal     G     SI2      62.6    54 18791  8.29  8.35  5.21
## # ... with 53,930 more rows
\end{verbatim}

Jednotlivé operace lze snadno kombinovat do větších celků. Řekněme, že nás např.~zajímá, jaká cena nejdražšího kamene pro každou barvu. Nejdříve rozdělíme tabulku do skupin podle barvy kamene, pak každou skupinu setřídíme podle ceny od nejvyšší po nejnižší, a~pak vybereme 1.~(tj.~nejdražší) kámen v~každé skupině.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{group\_by}\NormalTok{(color) }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{arrange}\NormalTok{(}\FunctionTok{desc}\NormalTok{(price)) }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{slice}\NormalTok{(1L)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 7 x 10
## # Groups:   color [7]
##   carat cut       color clarity depth table price     x     y     z
##   <dbl> <ord>     <ord> <ord>   <dbl> <dbl> <int> <dbl> <dbl> <dbl>
## 1  2.19 Ideal     D     SI2      61.8    57 18693  8.23  8.49  5.17
## 2  2.02 Very Good E     SI1      59.8    59 18731  8.11  8.2   4.88
## 3  1.71 Premium   F     VS2      62.3    59 18791  7.57  7.53  4.7 
## 4  2    Very Good G     SI1      63.5    56 18818  7.9   7.97  5.04
## 5  2    Very Good H     SI1      62.8    57 18803  7.95  8     5.01
## 6  2.29 Premium   I     VS2      60.8    60 18823  8.5   8.47  5.16
## 7  3.01 Premium   J     SI2      60.7    59 18710  9.35  9.22  5.64
\end{verbatim}

Data lze i~jednoduše agregovat. Můžeme např.~snadno spočítat průměrnou cenu pro každou barvu kamenů. Opět kameny rozdělíme do skupin podle barvy a pro každou skupinu vypočítáme průměrnou cenu kamenů ve skupině:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{group\_by}\NormalTok{(color) }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{summarise}\NormalTok{(}\AttributeTok{average\_price =} \FunctionTok{mean}\NormalTok{(price, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 7 x 2
##   color average_price
##   <ord>         <dbl>
## 1 D             3170.
## 2 E             3077.
## 3 F             3725.
## 4 G             3999.
## 5 H             4487.
## 6 I             5092.
## 7 J             5324.
\end{verbatim}

Kritéria je možné i~kombinovat. Následující tabulka obsahuje průměrnou cenu kamene pro kombinaci barvy a řezu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{group\_by}\NormalTok{(color, cut) }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{summarise}\NormalTok{(}\AttributeTok{average\_price =} \FunctionTok{mean}\NormalTok{(price, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 35 x 3
## # Groups:   color [7]
##    color cut       average_price
##    <ord> <ord>             <dbl>
##  1 D     Fair              4291.
##  2 D     Good              3405.
##  3 D     Very Good         3470.
##  4 D     Premium           3631.
##  5 D     Ideal             2629.
##  6 E     Fair              3682.
##  7 E     Good              3424.
##  8 E     Very Good         3215.
##  9 E     Premium           3539.
## 10 E     Ideal             2598.
## # ... with 25 more rows
\end{verbatim}

\hypertarget{ochutnuxe1vka-vizualizace-dat}{%
\section{Ochutnávka vizualizace dat}\label{ochutnuxe1vka-vizualizace-dat}}

Další část ochutnávky schopností jazyka~R se týká vizualizace dat, tj.~tvorby grafů. R~je schopné vytvářet komplexní grafy v~publikační kvalitě~-- a~přitom velmi elegantně a snadno. Všechny grafy v~tomto oddíle byly vytvořeny přímo v~R nebyly nijak ručně upravovány. Do webové i~PDF verze knihy je upravilo samo~R.

I~nadále budeme pracovat s~tabulkou \emph{diamonds}. Nejdříve ze všeho by nás mohlo zajímat, jak časté jsou různé ceny diamantů. K~tomuto účelu se obvykle používá histogram, viz obrázek~\ref{fig:appetizer-hist}, vytvořený následujícím kódem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{ggplot}\NormalTok{(}\FunctionTok{aes}\NormalTok{(price)) }\SpecialCharTok{+}
    \FunctionTok{geom\_histogram}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{theme\_bw}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{figure}
\centering
\includegraphics{appetizer_files/figure-latex/appetizer-hist-1.pdf}
\caption{\label{fig:appetizer-hist}Histogram rozdělení cen diamantů}
\end{figure}

Výsledek není překvapivý~-- čím vyšší cena, tím méně kamenů se za ni prodává. Zajímavější otázka však je, zda se ceny liší podle kvality řezu kamene. Zde nám histogram nepomůže. Existuje však celá řada jiných možností. První z~nich je tzv.~boxplot, viz obrázek~\ref{fig:appetizer-boxplot}. Výška každé krabice ukazuje mezikvartilovou vzdálenost, tlustá vodorovná čára mediánovou cenu a jednotlivé tečky odlehlá pozorování. Histogram byl vytvořen takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}\FunctionTok{aes}\NormalTok{(cut, price)) }\SpecialCharTok{+} 
    \FunctionTok{geom\_boxplot}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{theme\_bw}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{figure}
\centering
\includegraphics{appetizer_files/figure-latex/appetizer-boxplot-1.pdf}
\caption{\label{fig:appetizer-boxplot}Porovnání rozdělení cen podle typu řezu pomocí boxplotů}
\end{figure}

Výsledek je překvapivý: zdaleka neplatí, že dokonalejší řez znamená vyšší ceny. Možná je to však tím, že boxploty neukazují celý tvar statistického rozdělení, ale jen pár vybraných charakteristik tohoto rozdělení. Celé rozdělení můžeme zobrazit např.~pomocí odhadu jádrové hustoty. Abychom mohli pozorovat rozdíly mezi jednotlivými typy řezů, částečně grafy hustot zprůhledníme, viz obrázek~\ref{fig:appetizer-density} vytvořený takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}\FunctionTok{aes}\NormalTok{(price, }\AttributeTok{fill =}\NormalTok{ cut)) }\SpecialCharTok{+} 
    \FunctionTok{geom\_density}\NormalTok{(}\AttributeTok{alpha =} \FloatTok{0.35}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{theme\_bw}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{figure}
\centering
\includegraphics{appetizer_files/figure-latex/appetizer-density-1.pdf}
\caption{\label{fig:appetizer-density}Porovnání rozdělení cen podle typu řezu pomocí odhadů jádrové hustoty}
\end{figure}

Nejzajímavější otázky se však vždy týkají vztahů mezi veličinami. Řekněme, že nás například zajímá, jak souvisí cena kamene s~jeho váhou. Takový vztah dokáže pěkně zobrazit \emph{scatter plot}, viz obrázek~\ref{fig:appetizer-scatterplot}. Vlastní trend vztahu zobrazíme snadno přidáním regresní přímky. V~tomto grafu navíc nebudeme líní a změníme nápisy v~grafu do češtiny:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}\FunctionTok{aes}\NormalTok{(carat, price)) }\SpecialCharTok{+} 
    \FunctionTok{geom\_point}\NormalTok{(}\AttributeTok{alpha =} \FloatTok{0.05}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{geom\_smooth}\NormalTok{(}\AttributeTok{method =}\NormalTok{ lm) }\SpecialCharTok{+}
    \FunctionTok{xlab}\NormalTok{(}\StringTok{"váha"}\NormalTok{) }\SpecialCharTok{+} \FunctionTok{ylab}\NormalTok{(}\StringTok{"cena"}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{ylim}\NormalTok{(}\DecValTok{0}\NormalTok{, }\DecValTok{20000}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{theme\_bw}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{figure}
\centering
\includegraphics{appetizer_files/figure-latex/appetizer-scatterplot-1.pdf}
\caption{\label{fig:appetizer-scatterplot}Vztah mezi váhou kamenů a jejich cenou}
\end{figure}

Mohlo by nás ovšem zajímat, zda je vztah mezi cenou a váhou kamene stejný bez ohledu na barvu kamene. Abychom toho dosáhli, musíme do grafu přidat další rozměr. Na první pohled se zdá, že budeme potřebovat třírozměrný graf. Takové grafy jsou však velmi nepřehledné. R~má v~zásobě něco lepšího: umožní nám přidáním jednoho řádku do předchozího kódu rozdělit kameny do dílčích grafů, viz obrázek~\ref{fig:appetizer-scatterwrat}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}\FunctionTok{aes}\NormalTok{(carat, price)) }\SpecialCharTok{+} 
    \FunctionTok{geom\_point}\NormalTok{(}\AttributeTok{alpha =} \FloatTok{0.05}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{geom\_smooth}\NormalTok{(}\AttributeTok{method =}\NormalTok{ lm) }\SpecialCharTok{+}
    \FunctionTok{facet\_wrap}\NormalTok{(}\SpecialCharTok{\textasciitilde{}}\NormalTok{ color) }\SpecialCharTok{+}
    \FunctionTok{xlab}\NormalTok{(}\StringTok{"váha"}\NormalTok{) }\SpecialCharTok{+} \FunctionTok{ylab}\NormalTok{(}\StringTok{"cena"}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{ylim}\NormalTok{(}\DecValTok{0}\NormalTok{, }\DecValTok{20000}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{theme\_bw}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{figure}
\centering
\includegraphics{appetizer_files/figure-latex/appetizer-scatterwrat-1.pdf}
\caption{\label{fig:appetizer-scatterwrat}Vztah mezi váhou kamenů a jejich cenou při kontrole o barvu kamenů}
\end{figure}

\hypertarget{ochutnuxe1vka-regresnuxed-analuxfdzy}{%
\section{Ochutnávka regresní analýzy}\label{ochutnuxe1vka-regresnuxed-analuxfdzy}}

Nejdůležitějším nástrojem analýzy dat je beze sporu regrese. R~obsahuje nástroje pro velmi pokročilé regresní techniky, zde se však podíváme na jednoduchou lineární regresi. Pokusíme se vysvětlit, jak závisí cena diamantů na jejich charakteristikách, jako jsou váha, typ řezu, barva a velikost. Začneme tím, že odhadneme jednodušší model, který je popsaný rovnicí:

\[\textrm{price} = \beta_0 + \beta_1 \textrm{ carat} + \beta_2 \textrm{ color} + \beta_3 \textrm{ cut} + \beta_4 \textrm{ table} + \varepsilon.\]

Proměnné \texttt{cut}a \texttt{color} jsou kategoriální. R~pro ně automaticky připraví potřebné umělé proměnné. Nejdříve však tyto faktory převedeme na ne-ordinální, protože tak bude mít odhad modelu jednodušší interpretaci:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\OtherTok{\textless{}{-}} \FunctionTok{mutate}\NormalTok{(diamonds,}
                   \AttributeTok{color =} \FunctionTok{factor}\NormalTok{(color, }\AttributeTok{ordered =} \ConstantTok{FALSE}\NormalTok{),}
                   \AttributeTok{cut =} \FunctionTok{factor}\NormalTok{(cut, }\AttributeTok{ordered =} \ConstantTok{FALSE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

Vlastní model odhadneme takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ price }\SpecialCharTok{\textasciitilde{}}\NormalTok{ carat }\SpecialCharTok{+}\NormalTok{ color }\SpecialCharTok{+}\NormalTok{ cut }\SpecialCharTok{+}\NormalTok{ table}
\NormalTok{em }\OtherTok{\textless{}{-}} \FunctionTok{lm}\NormalTok{(model, diamonds)}
\FunctionTok{summary}\NormalTok{(em)  }\CommentTok{\# vypíše výsledek regrese}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
## Call:
## lm(formula = model, data = diamonds)
## 
## Residuals:
##      Min       1Q   Median       3Q      Max 
## -17351.4   -751.5    -84.3    544.7  12226.7 
## 
## Coefficients:
##               Estimate Std. Error t value Pr(>|t|)    
## (Intercept)  -2471.895    201.814 -12.248  < 2e-16 ***
## carat         8192.894     13.962 586.784  < 2e-16 ***
## colorE         -89.573     22.625  -3.959 7.53e-05 ***
## colorF         -72.834     22.772  -3.198  0.00138 ** 
## colorG        -106.719     22.070  -4.836 1.33e-06 ***
## colorH        -734.724     23.702 -30.999  < 2e-16 ***
## colorI       -1077.256     26.574 -40.537  < 2e-16 ***
## colorJ       -1909.932     32.863 -58.118  < 2e-16 ***
## cutGood       1120.648     41.223  27.185  < 2e-16 ***
## cutVery Good  1495.866     38.273  39.084  < 2e-16 ***
## cutPremium    1437.307     37.774  38.050  < 2e-16 ***
## cutIdeal      1742.944     38.589  45.167  < 2e-16 ***
## table          -21.951      3.366  -6.521 7.05e-11 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 1432 on 53927 degrees of freedom
## Multiple R-squared:  0.8713, Adjusted R-squared:  0.8712 
## F-statistic: 3.041e+04 on 12 and 53927 DF,  p-value: < 2.2e-16
\end{verbatim}

Často potřebujeme porovnat odhady různých specifikací modelu. Například by mohlo být zajímavé nahradit proměnnou \texttt{table} jiným měřítkem velikosti kamene. Zde odhadneme původní model a čtyři jeho alternativy:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}
\NormalTok{    model,}
\NormalTok{    model }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{update}\NormalTok{(. }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}}\NormalTok{ table }\SpecialCharTok{+}\NormalTok{ depth),}
\NormalTok{    model }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{update}\NormalTok{(. }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}}\NormalTok{ table }\SpecialCharTok{+}\NormalTok{ x),}
\NormalTok{    model }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{update}\NormalTok{(. }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}}\NormalTok{ table }\SpecialCharTok{+}\NormalTok{ y),}
\NormalTok{    model }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{update}\NormalTok{(. }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}}\NormalTok{ table }\SpecialCharTok{+}\NormalTok{ z)}
\NormalTok{)}
\NormalTok{em }\OtherTok{\textless{}{-}} \FunctionTok{map}\NormalTok{(model, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{lm}\NormalTok{(., }\AttributeTok{data =}\NormalTok{ diamonds))}
\end{Highlighting}
\end{Shaded}

Výsledky porovnáme v~přehledné tabulce s~názvem ``Výsledky odhadů různých specifikací modelů'':

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{stargazer}\NormalTok{(em, }\AttributeTok{type =} \FunctionTok{pandoc.output.format}\NormalTok{(), }\AttributeTok{df =} \ConstantTok{FALSE}\NormalTok{,}
          \AttributeTok{notes.append =} \ConstantTok{FALSE}\NormalTok{, }\AttributeTok{notes =} \StringTok{""}\NormalTok{, }\AttributeTok{header =} \ConstantTok{FALSE}\NormalTok{,}
          \AttributeTok{no.space =} \ConstantTok{TRUE}\NormalTok{,}
          \AttributeTok{title =} \StringTok{"Výsledky odhadů různých specifikací modelu"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{table}[!htbp] \centering 
  \caption{Výsledky odhadů různých specifikací modelu} 
  \label{} 
\begin{tabular}{@{\extracolsep{5pt}}lccccc} 
\\[-1.8ex]\hline 
\hline \\[-1.8ex] 
 & \multicolumn{5}{c}{\textit{Dependent variable:}} \\ 
\cline{2-6} 
\\[-1.8ex] & \multicolumn{5}{c}{price} \\ 
\\[-1.8ex] & (1) & (2) & (3) & (4) & (5)\\ 
\hline \\[-1.8ex] 
 carat & 8,192.894$^{***}$ & 8,183.774$^{***}$ & 11,041.860$^{***}$ & 9,492.338$^{***}$ & 9,725.135$^{***}$ \\ 
  & (13.962) & (13.889) & (58.130) & (42.709) & (43.207) \\ 
  colorE & $-$89.573$^{***}$ & $-$91.842$^{***}$ & $-$97.617$^{***}$ & $-$92.161$^{***}$ & $-$93.096$^{***}$ \\ 
  & (22.625) & (22.621) & (22.115) & (22.416) & (22.342) \\ 
  colorF & $-$72.834$^{***}$ & $-$72.405$^{***}$ & $-$52.582$^{**}$ & $-$61.845$^{***}$ & $-$62.069$^{***}$ \\ 
  & (22.772) & (22.767) & (22.262) & (22.564) & (22.488) \\ 
  colorG & $-$106.719$^{***}$ & $-$100.884$^{***}$ & $-$107.555$^{***}$ & $-$104.873$^{***}$ & $-$101.694$^{***}$ \\ 
  & (22.070) & (22.064) & (21.568) & (21.862) & (21.789) \\ 
  colorH & $-$734.724$^{***}$ & $-$727.123$^{***}$ & $-$761.310$^{***}$ & $-$744.271$^{***}$ & $-$740.949$^{***}$ \\ 
  & (23.702) & (23.703) & (23.172) & (23.484) & (23.404) \\ 
  colorI & $-$1,077.256$^{***}$ & $-$1,070.565$^{***}$ & $-$1,138.112$^{***}$ & $-$1,104.141$^{***}$ & $-$1,100.604$^{***}$ \\ 
  & (26.574) & (26.577) & (26.004) & (26.344) & (26.250) \\ 
  colorJ & $-$1,909.932$^{***}$ & $-$1,902.818$^{***}$ & $-$1,992.011$^{***}$ & $-$1,945.948$^{***}$ & $-$1,939.625$^{***}$ \\ 
  & (32.863) & (32.865) & (32.165) & (32.581) & (32.463) \\ 
  cutGood & 1,120.648$^{***}$ & 1,067.103$^{***}$ & 1,184.977$^{***}$ & 1,195.907$^{***}$ & 1,058.334$^{***}$ \\ 
  & (41.223) & (41.910) & (40.300) & (40.889) & (40.738) \\ 
  cutVery Good & 1,495.866$^{***}$ & 1,438.418$^{***}$ & 1,576.936$^{***}$ & 1,596.985$^{***}$ & 1,428.780$^{***}$ \\ 
  & (38.273) & (39.451) & (37.283) & (37.851) & (37.721) \\ 
  cutPremium & 1,437.307$^{***}$ & 1,342.996$^{***}$ & 1,545.595$^{***}$ & 1,509.262$^{***}$ & 1,316.495$^{***}$ \\ 
  & (37.774) & (39.854) & (36.970) & (37.474) & (37.444) \\ 
  cutIdeal & 1,742.944$^{***}$ & 1,724.554$^{***}$ & 1,873.955$^{***}$ & 1,880.359$^{***}$ & 1,706.301$^{***}$ \\ 
  & (38.589) & (38.768) & (36.460) & (37.001) & (36.909) \\ 
  table & $-$21.951$^{***}$ &  &  &  &  \\ 
  & (3.366) &  &  &  &  \\ 
  depth &  & $-$35.979$^{***}$ &  &  &  \\ 
  &  & (4.602) &  &  &  \\ 
  x &  &  & $-$1,232.425$^{***}$ &  &  \\ 
  &  &  & (24.372) &  &  \\ 
  y &  &  &  & $-$566.150$^{***}$ &  \\ 
  &  &  &  & (17.492) &  \\ 
  z &  &  &  &  & $-$1,082.736$^{***}$ \\ 
  &  &  &  &  & (28.780) \\ 
  Constant & $-$2,471.895$^{***}$ & $-$1,458.123$^{***}$ & 965.254$^{***}$ & $-$1,622.037$^{***}$ & $-$1,055.518$^{***}$ \\ 
  & (201.814) & (297.291) & (101.796) & (77.707) & (82.654) \\ 
 \hline \\[-1.8ex] 
Observations & 53,940 & 53,940 & 53,940 & 53,940 & 53,940 \\ 
R$^{2}$ & 0.871 & 0.871 & 0.877 & 0.874 & 0.874 \\ 
Adjusted R$^{2}$ & 0.871 & 0.871 & 0.877 & 0.874 & 0.874 \\ 
Residual Std. Error & 1,431.632 & 1,431.386 & 1,399.404 & 1,418.485 & 1,413.764 \\ 
F Statistic & 30,410.660$^{***}$ & 30,422.700$^{***}$ & 32,036.900$^{***}$ & 31,060.700$^{***}$ & 31,298.560$^{***}$ \\ 
\hline 
\hline \\[-1.8ex] 
\textit{Note:}  & \multicolumn{5}{r}{} \\ 
\end{tabular} 
\end{table}

\hypertarget{part-zuxe1klady}{%
\part{Základy}\label{part-zuxe1klady}}

\hypertarget{kap:basics}{%
\chapter{Základy práce s~R a s~RStudiem}\label{kap:basics}}

Dříve než se pustíme do studia~R, potřebujete jisté základy. V~této kapitole se naučíte

\begin{itemize}
\tightlist
\item
  jak nainstalovat R,
\item
  jak nainstalovat, zkonfigurovat a používat RStudio,
\item
  jak načíst, nainstalovat a aktualizovat balíky funkcí a dat,
\item
  jak číst dokumentaci a kde najít pomoc,
\item
  jak používat konzolu a
\item
  jak psát a spouštět skripty.
\end{itemize}

\hypertarget{instalace-r}{%
\section{Instalace R}\label{instalace-r}}

Analyzovat a vizualizovat data v~R se nenaučíte čtením knihy: sami si musíte hrát s~R a experimentovat se skutečnými nebo simulovanými daty. K~tomu budete potřebovat mít R nainstalované na svém počítači. V~tomto oddíle stručně popíšeme, jak R instalovat ve Windows a v~Linuxu. Instalace je v~obou případech nenáročná; v~Linuxu vám poskytneme několik rad, jak optimalizovat výkon~R.

Vlastní návod k~instalaci i instalační soubory najdete na \url{https://cran.r-project.org/}.
Instalace ve Windows je jednoduchá. Mimo jiné ji ukazuje tento tutoriál: \url{http://youtu.be/Ohnk9hcxf9M}.
Určité problémy mohou vzniknout, pokud máte v~cestě ke svému domovskému adresáři mezery a písmena s~háčky a čárkami. (Těm je však lepší se vždy vyhnout.) Pokud by standardní cesty kvůli mezerám, háčkům a čárkám nefungovaly, je možné nastavit jiné cesty, viz dále.

V~mnoha distribucích Linuxu je R obsaženo přímo ve standardních repositářích, a~to včetně jednotlivých přidaných balíků. Doporučuji se těmto balíků \emph{vyhnout}. Rozumnější je postupovat podle návodu na výše uvedené stránce: přidat si CRAN do repositářů a nainstalovat pouze jádro~R a ty balíky, které CRAN nabízí v~binární podobě. Ostatní balíky si nainstalujete přímo v~R. Tak budete mít vždy aktuální verze.

R používá k~maticovým výpočtům standardní numerické knihovny BLAS a LAPACK. Existuje několik verzí těchto knihoven, které se od sebe velmi liší výkonem. Mezi nejlepší patří OpenBLAS, AtlasBLAS a Intel MKL (pouze pro procesory značky Intel). V~Linuxu se implicitně používá nepříliš efektivní verze těchto knihoven, proto doporučujeme nainstalovat a zvolit některou efektivnější verzi. Výrazně tak zrychlíte mnoho svých výpočtů. Než si zvolíte jednu z~těchto knihoven, podívejte se na aktuální výsletky testů výkonosti na internetu. (V~současnosti je asi nejlepší obecnou volbou OpenBlas.)\footnote{Při volbě alternativních knihoven BLAS a LAPACK však buďte opatrní. Minimálně v~Ubuntu 20.04 jsou knihovny OpenBlas a Intel MKL pokažené~-- někdy skončí chybou, někdy vrací náhodný výsledek. V~této verzi je tedy nejlepší použít Atlas. Pro jiné verze googlete.}

V~Ubuntu naistalujete jednotlivé knihovny takto:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# instalace OpenBLAS}
\FunctionTok{sudo}\NormalTok{ apt install libopenblas{-}base}
\CommentTok{\# instalace ATLAS}
\FunctionTok{sudo}\NormalTok{ apt install libatlas3{-}base liblapack3}
\CommentTok{\# intalace Intel MKL}
\FunctionTok{sudo}\NormalTok{ apt install intel{-}mkl{-}full}
\end{Highlighting}
\end{Shaded}

Poslední nainstalovaný BLAS by se měl automaticky použít. Později jej můžete zkonfigovat takto:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# volba BLAS}
\FunctionTok{sudo}\NormalTok{ update{-}alternatives }\AttributeTok{{-}{-}config}\NormalTok{ libblas.so.3{-}x86\_64{-}linux{-}gnu}
\CommentTok{\# volba LAPACK}
\FunctionTok{sudo}\NormalTok{ update{-}alternatives }\AttributeTok{{-}{-}config}\NormalTok{ liblapack.so.3{-}x86\_64{-}linux{-}gnu}
\end{Highlighting}
\end{Shaded}

Funkce \texttt{sessionInfo()} v~R vypíše, kromě jiných informací, i~to, který BLAS a LAPACK vaše~R používá.
V~ostatních distribucích Linuxu budete zřejmě postupovat analogicky.

Volba efektivnějších verzí BLAS a LAPACK ve Windows je podstatně obtížnější a může zahrnovat kompilaci daných knihoven i~vlastního~R. Pokud si ji chcete vyzkoušet, hledejte na Internetu nejnovější návod.

\hypertarget{sec:basics-setting}{%
\section{RStudio}\label{sec:basics-setting}}

R~funguje jako program na příkazovém řádku (ve Windows má k~dispozici jednoduché grafické rozhraní). Pro vážnou práci s~ním je však vhodné použít nějaké vývojové prostředí (IDE). Nejlepší vývojové prostředí pro~R je v~současné době RStudio, které je šířené zdarma pod licencí AGPL~v3 pro Windows, Linux i~Mac. RStudio ke svému běhu potřebuje Javu (doporučuji oficiální Javu od Oracle, ne její svobodné ekvivalenty). Jak RStudio vypadá, ukazuje obrázek~\ref{fig:basics-rstudio}.

\begin{figure}
\includegraphics[width=6.58in]{figs/basics/RStudioScreenshot_small} \caption{Vývojové prostředí RStudio.}\label{fig:basics-rstudio}
\end{figure}

RStudio je zdarma ke stažení na www.rstudio.com, konkrétně na \url{https://rstudio.com/products/rstudio/download/}. Pro Windows je dispozici instalační soubor, pro Linux standardní balíky \texttt{.deb} a \texttt{.rpm}. Po instalaci byste měli jednou za čas zkontrolovat, zda máte nejnovější verzi RStudia, a~to v~menu RStudia \texttt{Help}\(\rightarrow\)\texttt{Check\ for\ Updates}.

RStudio se skládá z~obecného menu a čtyř panelů. Každý panel může obsahovat několik záložek. Můžete si zkonfigurovat, kde bude který panel, jak bude veliký a které záložky budou ve kterém panelu. Mezi hlavní záložky RStudia patří:

\begin{itemize}
\tightlist
\item
  \textbf{Konzola} (Console)~je určena pro interaktivní práci s~R. Kód, který do ní zapíšete, R okamžitě vyhodnotí a výsledky vypíše do konzoly nebo zobrazí jako graf.
\item
  \textbf{Editor} (Source)~-- slouží k~psaní skriptů. Kód, který do něj napíšete, můžete uložit a opakovaně spouštět a ladit. V~editoru můžete současně editovat libovolné množství souborů různých typů (R~script, R~markdown, textové dokumenty a mnohé další).
\item
  \textbf{Přehled prostředí~R} (Environment) zobrazuje všechny objekty (data, funkce apod.), které aktuálně žijí ve zvoleném prostředí v~R (implicitně v~globálním prostředí). Přehled prostředí také umožňuje importovat některé typy dat a mazat dříve vytvořené objekty.
\item
  \textbf{Soubory} (Files) zobrazují soubory a adresáře, které jsou v~aktuálním projektu nebo adresáři a umožňuje s~nimi dělat základní operace (mazat je, přejmenovávat apod.).
\item
  \textbf{Grafy} (Plots) zobrazují grafy, které jste v~R vykreslili. Tato záložka se otevře teprve ve chvíli, kdy nějaký graf vytvoříte.
\item
  \textbf{Balíky} (Packages) zobrazují seznam instalovaných balíků. Zároveň umožňují i~balíky načítat, instalovat, aktualizovat a odstraňovat.
\item
  \textbf{Nápověda} (Help) zobrazuje dokumentaci k~funkcím, datům a balíkům.
\item
  \textbf{Historie} (History) zobrazuje kód, který jste v~minulosti spustili v~konzoli. Umožňuje jej také uložit a přesunout do konzoly a do editoru.
\end{itemize}

Další typy záložek se objeví v~případě, že budete dělat něco pokročilého, např.~budete používat \texttt{make} nebo správu verzí.

Ikona \emph{Workspace Panes} (vypadá jako čtyři malá okénka) umožňuje jednotlivé panely a záložky dočasně zvětšit přes celou obrazovku (po ťuknutí zobrazí klávesové zkratky).

V~pravém horním rohu RStudia je přepínač projektů. \textbf{Projekty} umožňují elegantně oddělit různé projekty, na kterých současně pracujete. Každý projekt má svůj vlastní adresář, vlastní proces~R atd. Víc o~projektech najdete na \url{https://goo.gl/CxyHVS}.

Doporučuji, abyste si před vlastní prací RStudio zkonfigurovali. Z~menu RStudia vyvolejte \texttt{Tools}\(\rightarrow\)\texttt{Global\ Options...} a nastavte, jak se má RStudio chovat. Vysvětlení jednotlivých položek najdete např.~na stránce \url{https://support.rstudio.com/hc/en-us/articles/200549016-Customizing-RStudio}. Doporučuji zejména následující nastavení (moje nastavení ukazují obrázky \ref{fig:basics-rstudio-setting1} a \ref{fig:basics-rstudio-setting2}):

\begin{itemize}
\tightlist
\item
  V~záložce \texttt{General} doporučuji vypnout \texttt{Restore\ .RData\ into\ workspace} a nastavit \texttt{Save\ workspace\ to\ .RData\ on\ exit} na \texttt{Never}. V~opačném případě se vám na začátku sezení nahrají do paměti výsledky výpočtů z~předchozího sezení. Na první pohled to vypadá to jako dobrý nápad a úspora času, ale ve skutečnosti je to zdroj chyb, které se špatně hledají. Měli byste si zvyknout, že veškeré výpočty máte uložené v~podobě skriptu a můžete je tedy kdykoli znovu provést.
\item
  V~záložce \texttt{Code}\(\rightarrow\)\texttt{Editing} si zapněte \texttt{Insert\ spaces\ for\ tab} a \texttt{Tab\ width} nastavte aspoň na 4.
\item
  V~záložce \texttt{Code}\(\rightarrow\)\texttt{Display} zapněte vše (snad kromě \texttt{Highlight\ selected\ line}) a \texttt{Margin\ column} nastavte na hodnotu kolem~80 nebo 90.
\item
  V~záložce \texttt{Code}\(\rightarrow\)\texttt{Saving} zapněte vše. Zvažte, zda nenastavit kódování na UTF-8, což je rozumný standard pro výměnu textů.
\item
  V~záložce \texttt{Code}\(\rightarrow\)\texttt{Completetion} zapněte vše snad kromě \texttt{Show\ help\ tooltip\ on\ cursor\ idle}.
\item
  V~záložce \texttt{Code}\(\rightarrow\)\texttt{Diagnostics} zapněte vše. Tak vám RStudio bude při psaní kódu v~editoru zobrazovat diagnostické rady.
\item
  V~záložce \texttt{Sweave} nastavte \texttt{Weave\ Rnw\ files\ using} na \texttt{knitr} a \texttt{Typeset\ LaTeX\ into\ PDF\ using} na \texttt{pdflatex}
\end{itemize}

\begin{figure}
\includegraphics[width=3.29in]{figs/basics/RstudioSettingGeneralBasic} \includegraphics[width=3.28in]{figs/basics/RstudioSettingSweave} \caption{Nastavení obecných částí RStudia.}\label{fig:basics-rstudio-setting1}
\end{figure}

\begin{figure}
\includegraphics[width=3.29in]{figs/basics/RstudioSettingCodeEditing} \includegraphics[width=3.29in]{figs/basics/RstudioSettingCodeDisplay} \includegraphics[width=3.29in]{figs/basics/RstudioSettingCodeSaving} \includegraphics[width=3.29in]{figs/basics/RstudioSettingCodeCompletion} \includegraphics[width=3.3in]{figs/basics/RstudioSettingCodeDiagnostics} \includegraphics[width=3.29in]{figs/basics/RstudioSettingPaneLayout} \caption{Nastavení editoru RStudia.}\label{fig:basics-rstudio-setting2}
\end{figure}

Pokud jste hračičkové, můžete si stáhnout a nainstalovat do systému nějaký font, který podporuje ligatury technických symbolů, a~v~menu \texttt{Tools}\(\rightarrow\)\texttt{Global\ Options...}\(\rightarrow\)\texttt{Appearance} si jej nastavit jako \texttt{Editor\ font}. Pak se vám budou některé symboly složené z~více znaků jako je např.~\texttt{\textless{}-}, \texttt{\textbar{}\textgreater{}}, \texttt{\textgreater{}=}, \texttt{==}, \texttt{!=} apod. zobrazovat jako jeden znak (v~kódu budou samozřejmě stále oba). Vhodný font jen např.~\texttt{JetBrains\ Mono} (\url{https://www.jetbrains.com/lp/mono/}) nebo \texttt{FiraCode} (\url{https://github.com/tonsky/FiraCode}).

Kromě menu můžete RStudio ovládat i pomocí klávesových zkratek. Seznam klávesových zkratek se zobrazí po volbě menu \texttt{Tools}\(\rightarrow\)\texttt{Keyboard\ shortcuts\ help} nebo po stisku \texttt{Alt+Shift+K}. Úplný seznam klávesových zkratek najdete i~na \url{https://goo.gl/aPSel6}.

R lze ukončit funkcí \texttt{q()}. Pokud běží v~RStudiu, ukončíte jej jednoduše buď v~menu \texttt{File}\(\rightarrow\)\texttt{Quit\ Session...} nebo křížkem okna.
R~standardně při ukončení uloží všechny objekty v~paměti (data, uživatelem definované funkce apod.) do souboru a při opětovném spuštění je opět načte (netýká se načtených balíků~-- ty je třeba načíst pokaždé znovu). Někdy se to hodí, ale často je to zdrojem chyb, které se špatně hledají. Doporučuji tuto funkci v~nastavení zakázat, viz výše.

Schopnosti RStudia je možné rozšířit pomocí ``doplňků'' (\emph{addins}). Doplňky se instalují jako běžné balíky~R (viz následující oddíly) a po instalaci jsou dostupné v~roletce \texttt{Addins} v~paletě nástrojů RStudia. Pokud si nainstalujete balík \textbf{addinslist}, přibude vám v~menu doplňků volba \texttt{Browse\ RStudio\ addins}, která vám zobrazí dostupné doplňky, jejich popisy a umožní je jednoduše instalovat.

Různé návody k~používání RStudia najdete zde na adrese \url{https://goo.gl/ik2Yb9}.
Cheatsheet pro používání RStudia získáte v~menu \texttt{Help}~\(\rightarrow\)~\texttt{Cheatsheets}~\(\rightarrow\) \texttt{RStudio\ IDE\ Cheat\ Sheet}.

\hypertarget{baluxedky}{%
\section{Balíky}\label{baluxedky}}

Všechny funkce, datové struktury, data i~vše ostatní je v~R organizováno do balíků. Základní balíky (\texttt{base}, \texttt{methods}, \texttt{datasets}, \texttt{utils} apod.) jsou přítomny v~každé instalaci~R a načtou se automaticky při jeho spuštění. Ostatní balíky je potřeba nainstalovat a před použitím načíst do paměti ``ručně''.
Seznam balíků, které máte aktuálně nainstalované, můžete v~RStudiu zobrazit v~záložce \texttt{Packages}. Balíky, které jsou aktuálně načtené do paměti, mají v~seznamu zapnuté zaškrtávátko.

Pokud máte nějaký balík nainstalovaný, můžete jej začít používat. R~však samo o~sobě o~objektech uložených v~balících neví. Před jejich použitím je tedy třeba načíst balík do paměti (ve skutečnosti se načtou jen jména objektů v~balíku do cesty, ve které R jednotlivé objekty hledá). K~tomu slouží funkce \texttt{library()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(dplyr)   }\CommentTok{\# v závorce je jméno funkce}
\end{Highlighting}
\end{Shaded}

Data a funkce z~balíku je možné využít i~bez jeho načtení pomocí operátoru \texttt{::}, kterým se oddělí jméno balíku a jméno funkce. To se hodí zejména ve dvou situacích: 1)~Při načtení nového balíku se někdy stane, že objekty z~nově načteného balíku překryjí data a funkce z~balíku, který jste načetli dříve. Dvojtečkový operátor vám umožní použít i~tyto ``překryté'' objekty. 2)~Někdy chcete použít jen jednu funkci a nechcete načítat celý balík. Pokud bychom tedy nenačetli balík \textbf{dplyr}, stále bychom mohli použít jednu z~jeho funkcí takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{dplyr}\SpecialCharTok{::}\FunctionTok{anti\_join}\NormalTok{()  }\CommentTok{\# jméno\_balíku::jméno\_funkce()}
\end{Highlighting}
\end{Shaded}

Pokud ovšem máte balík načtený pomocí funkce \texttt{library()}, můžete funkci zavolat jen jejím jménem bez jména balíku:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{anti\_join}\NormalTok{()  }\CommentTok{\# jméno funkce z načteného balíku}
\end{Highlighting}
\end{Shaded}

Pokud chcete použít jakýkoli balík, musíte jen nejdříve nainstalovat. Instalace balíků v~R je snadná, protože jejich valná většina je k~dispozici v~centralizovaných repositářích. Hlavním repositářem je CRAN (\url{https://cran.r-project.org/}). V~RStudiu nainstalujete balíky z~CRANu tak, že v~záložce \texttt{Packages} kliknete na tlačítko \texttt{Install}. (Při první instalaci je třeba nastavit adresu zrcadla CRANu, ze kterého se budou balíky stahovat. Doporučuji použít zrcadlo \texttt{Global\ CDN\ RStudio}.) K~ruční instalaci balíků slouží funkce \texttt{install.packages()}.
Balíky se neustále vyvíjejí (většinou zlepšují) a obvykle je dobré mít instalovány poslední verze. K aktualizaci balíků nainstalovaných z~CRANu slouží v~RStudiu v~záložce \texttt{Packages} klikátko \texttt{Update}.

Kromě CRANu existuje i~několik dalších repositářů. Nejvýznamnějším z~nich je GitHub. GitHub (\url{https://github.com/}) obsahuje vývojové verze balíků a nové balíky, které se dosud nedostaly na CRAN. Návod, jak instalovat balíky z~GitHubu, najdete na \url{https://goo.gl/ttEz9J}.

Implicitně se balíky instalují do uživatelského adresáře. V~tomto adresáři se vytvoří vždy nový podadresář pro každou novou verzi~R. To je proto, že při větší aktualizaci~R už nemusejí původní balíky fungovat a je třeba je znovu stáhnout nebo zkompilovat.

Pokud máte v~cestě k~do uživatelského adresáře umístěny znaky s~diakritiku (např.~proto, že jméno vašeho uživatelského je např.~účtu \texttt{Jiřík}), nebudou věci fungovat správně. Zejména vám nepůjdou spustit skripty (ani pomocí tlačítka \texttt{Source} v~RStudiu) a nepůjdou vám instalovat a načítat balíky. Problém se skripty vyřešíte snadno: vytvoříte někde adresář na práci a tam budete skladovat své skripty.
Problém s~balíky vyřešíte tak, že si vytvoříte alternativní knihovnu. Knihovna je adresář, kde R instaluje a hledá balíky. Postup je následující:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\item
  Vytvořte si adresář, kam můžete zapisovat a který neobsahuje v~cestě divné znaky, ve Windows např.~adresář \texttt{C:/Rlibs}. Následně si ověřte, že je nastaven pro čtení i~zápis.
\item
  Ve svém domovském adresáři vytvořte soubor \texttt{.Rprofile} a zapište do něj \texttt{.libPaths("C:/Rlibs")}. Všimněte si, že místo zpětných lomítek používáme v~cestě obyčejná lomítka (jinak musíte zpětná lomítka zdvojit, tj.~psát \texttt{\textbackslash{}\textbackslash{}}). Pokud soubor neexistuje, stačí v~R spustit následující řádek:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{writeLines}\NormalTok{(}\StringTok{\textquotesingle{}.libPaths("C:/Rlibs")\textquotesingle{}}\NormalTok{, }\AttributeTok{con =} \StringTok{"\textasciitilde{}/.Rprofile"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}
\item
  Po restartu RStudia se budou balíky hledat v~tomto adresáři. Při instalaci balíků klikněte na pulldown menu ``Install to Library:'' a~vyberte tento adresář. RStudio by si jej mělo po první instalaci balíku do tohoto adresáře pamatovat jako defaultní volbu
\end{enumerate}

V~Linuxu se balíky při instalaci kompilují pro váš operační systém, zatímco ve Windows se stahují už zkompilované. Pokud chcete mít možnost kompilovat balíky ze zdrojového kódu i~ve Windows, musíte nainstalovat \texttt{RTools}. Stáhnout si je můžete zde: \url{https://cran.r-project.org/bin/windows/Rtools/}. Po jejich instalaci je třeba přidat je do vyhledávací cesty. Návod je opět na této stránce stránce. Nejjednodušší způsob, jak to udělat, je zpsat cestu do souborou \texttt{.Renviron} ve vašem domovském adresáři. Pokud tento soubor neexistuje, stačí v~R spustit řádek:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{writeLines}\NormalTok{(}\StringTok{\textquotesingle{}PATH="$\{RTOOLS40\_HOME\}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{usr}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{bin;$\{PATH\}"\textquotesingle{}}\NormalTok{, }\AttributeTok{con =} \StringTok{"\textasciitilde{}/.Renviron"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Pokud jste si jistí, že nechcete balíky kompilovat, pak RTools v~zásadě nepotřebujete. R~však bude v takovém případě vypisovat následující varování:

\begin{verbatim}
WARNING: Rtools is required to build R packages but is not currently installed.
Please download and install the appropriate version of Rtools before proceeding:
http://cran.rstudio.com/bin/windows/Rtools/
\end{verbatim}

V~Linuxu jsou nástroje pro kompilaci balíků přítomné automaticky, takže žádné další kroky k~instalaci \texttt{RTools} nejsou potřeba.

\hypertarget{nuxe1povux11bda}{%
\section{Nápověda}\label{nuxe1povux11bda}}

Nikdo si nemůže pamatovat všechno~-- a~pamatovat si detaily použití jednotlivých funkcí je absurdní. Proto má R velmi dobrý systém nápovědy a dokumentace. RStudio tento systém ještě dále vylepšuje. Je velmi důležité, abyste se naučili dokumentaci k~funkcím číst.

Nápovědu ke zvolené funkci můžete získat jedním ze tří způsobů. V~konzoli napíšete jméno funkce (např.~funkce \texttt{mean()}) bez závorek za otazníkem nebo jako argument funkce \texttt{help()}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{?mean        }\CommentTok{\# za otazníkem je jméno funkce}
\FunctionTok{help}\NormalTok{(}\StringTok{"mean"}\NormalTok{) }\CommentTok{\# v uvozovkách je jméno funkce}
\end{Highlighting}
\end{Shaded}

nebo po napsání jména funkce do konzoly nebo editoru zmáčknete v~RStudiu klávesu~\texttt{F1}.
Všechny tyto cesty vedou ke stejnému výsledku: RStudio zobrazí stránku nápovědy k~dané funkci.

Jedna stránka nápovědy může dokumentovat několik různých funkcí, které mají něco společného. Stránky dokumentace mají v~R standardní strukturu. Je potřeba, abyste se s~ní seznámili. Stránka dokumentace má následující strukturu:

\begin{itemize}
\tightlist
\item
  \textbf{Název funkce nebo tématu a balíku}, např. \texttt{mean\ \{base\}}. To znamená, že strana dokumentuje funkci \texttt{mean()} definovanou v~balíku \texttt{base}.
\item
  \textbf{Jméno stránky dokumentace}, zde ``Arithmetic Mean''.
\item
  \textbf{Popis, co funkce dělají} (Description).
\item
  \textbf{Popis syntaxe}, jak se funkce používají (Usage). Zde se uvádí zejména to, jaké má funkce parametry a jaké mají tyto parametry implicitní hodnoty (pokud nějaké mají) a. Ve funkci \texttt{mean()} je prvním parametrem~\texttt{x}, který žádnou implicitní hodnotu nemá. Naproti tomu parametry \texttt{trim} a \texttt{na.rm} implicitní hodnoty mají. Pokud jejich hodnoty nezadáte, použijí se tyto implicitní hodnoty, tj.~např.~\texttt{trim} bude mít hodnotu~0. Všimněte si, že jednotlivé parametry jsou oddělené čárkou (\texttt{,}).
\item
  \textbf{Vysvětlení parametrů} (Arguments). V~této části se vysvětluje, co parametr představuje a v~jaké datové struktuře má být parametr uložený.
\item
  \textbf{Hodnota funkce} (Value) je oddíl, kde se vysvětluje, jaké hodnoty funkce vrací, co znamenají a v~jaké datové struktuře je hodnota funkce uložená.
\item
  \textbf{Odkazy na literaturu} (References).
\item
  \textbf{Odkazy na jiné funkce, balíky nebo data} (See Also) uvádějí seznam funkcí, které nějak souvisejí s~funkcemi, jejichž dokumentaci právě čtete.
\item
  \textbf{Příklady použití funkcí} (Examples) ukazují, jak funkci použít. Často pomáhají pochopit, jak funkce funguje a jak ji použít.
\end{itemize}

Pokud dokumentaci otevřete v~RStudiu, budou všechny odkazy klikací.

V~R nemají dokumentaci jen jednotlivé funkce a datasety, ale i~celé balíky.
Dokumentaci k~balíkům včetně seznamu funkcí, které jsou v~ní obsažené, je možné získat dvěma způsoby. Buď v~konzoli zavoláte funkci \texttt{help()} s~parametrem \texttt{package}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{help}\NormalTok{(}\AttributeTok{package =} \StringTok{"dplyr"}\NormalTok{)  }\CommentTok{\# v uvozovkách je jméno balíku}
\end{Highlighting}
\end{Shaded}

nebo v~RStudiu v~záložce Packages kliknete na jméno zvoleného balíku.
Dokumentace k~balíkům ukazuje, co vše daný balík nabízí. Obsahuje zejména soubor \texttt{DESCRIPTION}, který vysvětluje, kdo balík napsal, k~čemu slouží a na jakých jiných balících závisí. Často obsahuje i~odkaz na webovou stránku, kde se o~daném balíku můžete dozvědět více. Dále může dokumentace balíků obsahovat seznam vinět a seznam funkcí a dat, které vám balík poskytuje.

Viněty jsou texty, které se nezaměřují na jednotlivé funkce, nýbrž ukazují, jak se balík používá jako celek, nebo vysvětlují nějaký princip, na kterém balík stojí. Seznam vinět přítomných v~daném balíku je možné zobrazit v~dokumentaci balíku kliknutím na ``User guides, package vignettes and other documentation'' nebo v~konzoli pomocí funkce \texttt{vignette()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{vignette}\NormalTok{(}\AttributeTok{package =} \StringTok{"dplyr"}\NormalTok{) }\CommentTok{\# v uvozovkách je jméno balíku}
\end{Highlighting}
\end{Shaded}

Jednotlivou vinětu můžete zobrazit zobrazit kliknutím na její jméno v~seznamu v~RStudiu, nebo můžete v~konzoli zadat jméno viněty do funkce \texttt{vignette()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{vignette}\NormalTok{(}\StringTok{"introduction"}\NormalTok{, }\AttributeTok{package =} \StringTok{"dplyr"}\NormalTok{) }\CommentTok{\# první parametr je jméno viněty}
\end{Highlighting}
\end{Shaded}

Mnoho funkcí a balíků má k~dispozici i~demonstrační kód. Tyto kódy ukazují možnosti použití balíku nebo funkce nebo jejich obecné schopnosti. Tento kód můžete spustit takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{demo}\NormalTok{(}\StringTok{"graphics"}\NormalTok{) }\CommentTok{\# parametr funkce je téma / jméno demonstrace}
\FunctionTok{demo}\NormalTok{(}\StringTok{"bench{-}set"}\NormalTok{, }\AttributeTok{package =} \StringTok{"dplyr"}\NormalTok{) }\CommentTok{\# pokud není balík načtený}
\end{Highlighting}
\end{Shaded}

Pokud chcete zjistit, jaké demonstrace obsahuje nějaký balík, zadejte

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{demo}\NormalTok{(}\AttributeTok{package =} \StringTok{"dplyr"}\NormalTok{) }\CommentTok{\# v uvozovkách je jméno balíku}
\end{Highlighting}
\end{Shaded}

a RStudio otevře záložku se jmény demonstrací přítomných v~daném balíku. Pak vyvoláte demonstraci obvyklým způsobem.

\hypertarget{kde-najuxedt-pomoc}{%
\section{Kde najít pomoc}\label{kde-najuxedt-pomoc}}

Někdy dokumentace R nestačí. To se děje typicky ve chvíli, když nevíte, v~jaké funkci a v~jakém balíku je implementovaná nějaká metoda, kterou potřebujete, nebo ve chvíli, když dostanete chybovou hlášku, které nerozumíte. Když se do takové situace dostanete, zeptejte se Googlu.

Řekněme například, že potřebujete zjistit, jak neparametricky porovnat shodu střední hodnoty, ale nevíte, kterou funkci použít; navíc si ani nemůžete vzpomenout, jaký statistický test provést. Stačí, když Googlu položíte tento (nesprávný) dotaz: ``r non-parametric t test''. Uvidíte, že dostanete několik odkazů, které budou naprosto dokonale relevantní.

Někdy jste však v~situaci, kdy si opravdu nevíte rady a potřebujete položit dotaz živému člověku. K tomu slouží celá řada fór. Z~nich nejdůležitější je StackOverflow (\url{https://stackoverflow.com/}).

\hypertarget{konzola}{%
\section{Konzola}\label{konzola}}

R~umožňuje práci ve dvou režimech: interaktivní práci a spouštění skriptů. K~interaktivní práci s~R slouží konzola (Console). Všechny výrazy, které sem napíšete za prompt (zobák, ``\texttt{\textgreater{}}''), se okamžitě vyhodnotí a výsledky se vypíší zpět do konzole, tj.~``na obrazovku''.
Konzola tak slouží jako kalkulačka. Zkuste do ní zapsat následující výrazy a každý z~nich ``odeslat'' klávesou \texttt{Enter}. V~této knize je výstup kódu v~textu uvozen dvěma křížky (\texttt{\#\#}).

\begin{Shaded}
\begin{Highlighting}[]
\FloatTok{2.3} \SpecialCharTok{+} \DecValTok{3} \SpecialCharTok{*} \DecValTok{4}      \CommentTok{\# výraz se okamžitě vyhodnotí}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 14.3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}}\NormalTok{ (}\DecValTok{1}\SpecialCharTok{:}\DecValTok{20}\NormalTok{) }\SpecialCharTok{/} \DecValTok{3}  \CommentTok{\# přiřazení hodnot do proměnné x (nic nevypíše)}
\FunctionTok{print}\NormalTok{(x)         }\CommentTok{\# vypsání hodnot proměnné x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] 0.3333333 0.6666667 1.0000000 1.3333333 1.6666667 2.0000000 2.3333333
##  [8] 2.6666667 3.0000000 3.3333333 3.6666667 4.0000000 4.3333333 4.6666667
## [15] 5.0000000 5.3333333 5.6666667 6.0000000 6.3333333 6.6666667
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x                }\CommentTok{\# totéž, co print(x)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] 0.3333333 0.6666667 1.0000000 1.3333333 1.6666667 2.0000000 2.3333333
##  [8] 2.6666667 3.0000000 3.3333333 3.6666667 4.0000000 4.3333333 4.6666667
## [15] 5.0000000 5.3333333 5.6666667 6.0000000 6.3333333 6.6666667
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{y }\OtherTok{\textless{}{-}} \FunctionTok{sin}\NormalTok{(x)      }\CommentTok{\# vyhodnocení funkce a přiřazení do proměnné y  (nic nevypíše)}
\FunctionTok{plot}\NormalTok{(x, y)       }\CommentTok{\# vykreslení hodnot}
\end{Highlighting}
\end{Shaded}

\includegraphics{basics_files/figure-latex/unnamed-chunk-16-1.pdf}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{rm}\NormalTok{(x, y)         }\CommentTok{\# vymazání proměnných x a y}
\CommentTok{\# vše za symbolem křížku až do konce řádku je komentář {-}{-} R to ignoruje }
\end{Highlighting}
\end{Shaded}

Všimněte si, že k~přiřazení hodnoty do proměnné se v~R používá značka \texttt{\textless{}-} a k~oddělení desetinných míst čísla se používá desetinná tečka, zatímco čárka slouží k~oddělení jednotlivých parametrů funkce. Pokud tedy napíšete

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{median}\NormalTok{(}\DecValTok{2}\NormalTok{,}\DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2
\end{verbatim}

funkce nespočítá medián z~hodnoty 2.5, nýbrž medián z~hodnoty~2; číslo~5 se funkci předá jako její druhý parametr, což je zde \texttt{na.rm}. Obecně platí, že první hodnota zadaná do funkce představuje její první parametr, druhá hodnota druhý parametr atd. Parametry, které mají implicitní hodnoty, můžete vynechat. Víc se o~těchto věcech dozvíte v~oddíle~\ref{sec:function-call}.

V~RStudiu má konzola dvě užitečné klávesové zkratky: šipky nahoru a dolů umožňují procházet historií minulých výrazů. Pokud tedy zadáte a spustíte výraz, můžete jej spustit znovu tak, že zmáčknete šipku nahoru a \texttt{Enter}. Ke složitějšímu vyhledávání slouží \texttt{Ctrl-}šipky. Ty prochází seznam historie tak, že uvažují jen ty výrazy, které začínají stejně jako to, co jste právě napsali na prompt konzoly.

\hypertarget{sec:basics-skripts}{%
\section{Skripty}\label{sec:basics-skripts}}

Konzola slouží k~experimentování a ladění kódu. Ke skutečné práci však slouží skripty, které vám umožní spouštět kód opakovaně a při tom jej měnit a ladit. Za výsledek své práce byste nikdy neměli považovat výsledky interaktivního hraní v~konzoli, ať už ve formě spočítaných výsledků nebo vykreslených grafů, ale právě funkční skript. Pokud se ke své práci po čase vrátíte, nedokážete z~``výsledků'' nijak zjistit, jak jste k~nim dospěli (a~jestli jste v~průběhu neudělali chybu), ani něco v~již proběhlém výpočtu změnit. Naproti tomu skript jasně říká, co jste udělali, umožňuje, abyste svůj výpočet upravili a samozřejmě umožňuje i~znovu získat jakékoli výsledky, ke kterým jste dospěli. Měli byste si tedy zvyknout pracovat primárně v~editoru a konzoli používat jen k~testování dílčích kusů kódu.

R~skript je obyčejný textový soubor, do kterého napíšete R-kové výrazy jeden za druhý~-- každý nový výraz na nový řádek. Když pak skript spustíte, tyto řádky se provedou úplně stejně, jako byste je napsali přímo do konzoly. Jedinou výjimkou je část řádku za znakem křížku (\texttt{\#}), která se považuje za komentář~-- R~tuto část řádku ignoruje.

Skripty je zvykem ukládat do souborů s~koncovkou \texttt{.R}. Soubor se skriptem můžete vytvořit v~jakémkoli textovém editoru, který k~textu nepřidává žádné značky, tj.~např.~ne v~MS~Wordu. RStudio však poskytuje velmi dobrý editor, který umí barevně zvýraznit syntaxi, odhalit některé chyby, napovědět vám, jak se funkce jmenuje a jaké má parametry atd. Nový skript vytvoříte v~RStudiu klávesovou zkratkou \texttt{Ctrl}-\texttt{Shift}-\texttt{N} nebo v~menu \texttt{File}\(\rightarrow\)\texttt{New\ File}\(\rightarrow\)\texttt{R\ Script}.

Kvůli ladění chyb i~kvůli čitelnosti kódu je dobré skripty pěkně formátovat. Doporučuji dodržovat některý z~následujících stylů:

\begin{itemize}
\tightlist
\item
  styl Hadleyho Wickhama \url{http://adv-r.had.co.nz/Style.html} nebo
\item
  styl Googlu \url{https://google.github.io/styleguide/Rguide.xml}.
\end{itemize}

RStudio vás dokáže upozornit na špatný styl, pokud si tuto volbu zapnete, a~umí i~částečně váš skript přeformátovat do pěknějšího (v~menu \texttt{Code}\(\rightarrow\)\texttt{Reformat\ code}); pomáhá také možnost automaticky odsadit řádky kódu (v~menu \texttt{Code}\(\rightarrow\)\texttt{Reindent\ lines}) a pěkně zarovnat komentáře (v~menu \texttt{Code}\(\rightarrow\)\texttt{Reflow\ comments}).

Jednou napsaný skript můžete spouštět znovu a znovu. Skript je možné spustit třemi způsoby. V~RStudiu k tomu slouží klikátko \texttt{Source} v~pravém horním rohu editoru a klávesová zkratka \texttt{Ctrl}-\texttt{Shift}-\texttt{S}. Skript jde samozřejmě spustit i~z~konzoly nebo jiného skriptu pomocí funkce \texttt{source()}:

\begin{Shaded}
\begin{Highlighting}[]
 \CommentTok{\# jméno souboru do uvozovek}
 \FunctionTok{source}\NormalTok{(}\StringTok{"jmeno\_skriptu\_a\_cesta\_k\_němu"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Funkce \texttt{source()} má mnoho dalších parametrů, viz dokumentace. Užitečný je zejména logický parametr \texttt{echo}, který ovlivňuje, zda se při spuštění skriptu vypisují do konzoly výrazy, které se právě vyhodnocují. Klikátko \texttt{Source} v~RStudiu má podobnou volbu.

Někdy nechceme spustit celý skript naráz, ale chcete spouštět jen jednotlivé řádky kódu. Aktuální řádek nebo skupinu vybraných řádků spustíte klávesovou zkratkou \texttt{Ctrl+Enter}. Další možnosti spuštění skupin řádků a jejich klávesové zkratky najdete v~menu \texttt{Code}.

I~když skript může obsahovat všechny platné výrazy jazyka~R, některé z~nich není vhodné do skriptu umisťovat. Mezi takové výrazy patří zejména funkce, které mění vnější prostředí~R. Ve skriptu zejména nikdy neinstalujte balíky pomocí funkce \texttt{install.packages()} a raději ani neměňte pracovní adresář pomocí funkce \texttt{setwd()}. Je bezohledné, pokud s~někým sdílíte svůj skript a v~něm voláte takové funkce, protože tím měníte nastavení cizího počítače.

Naproti tomu nesmíte zapomenout ve skriptu načíst balíky, které používáte, pomocí funkce \texttt{library()}. Je rozumné, abyste balíky načetli vždy na začátku skriptu. Díky domu snadno dohledáte, které balíky skutečně voláte (a~které tedy musíte mít nainstalované).

Pokud jste nastavili RStudio tak, jak jsme uvedli v~oddíle~\ref{sec:basics-setting}, pak vám RStudio bude poskytovat velmi užitečné diagnostické rady pomocí ikonek zobrazených vlevo od čísel řádků kódu. Pokud na ikonku ``najedete myší'', zobrazí se diagnostická rada. Pro větší přehlednost RStudio vlnovkou podtrhne vyhodnocovaný kus kódu. Červená barva signalizuje chybu, žlutá varování a modrá upozornění na porušení stylistických konvencí, které sice nezabrání běhu vašeho kódu, ale znesnadňují jeho čtení.

Ukažme si použití skriptu na příkladů převzatém z~knihy Radové a Dvořáka: \emph{Finanční matematika pro každého}, Grada, 1993, s.~92--95. Neděste se, že zatím nebudete rozumět všemu, co kód dělá~-- postupně se všechno potřebné dozvíte v~této knize. Předkládejme, že musíme splácet dluh ve výši~\(D=\textrm{40 000}\) pomocí \(n=6\) stejných ročních splátek, tj.~anuit. Úroková sazba je~\(i=12\)~\%. Kniha nám říká, že výši anuity~\(A\), úrokové platby~\(U\) a úmoru~\(M\) (anuita je úroková platba plus úmor) můžeme spočítat podle následujících vztahů, kde \(t\) je čas:

\begin{align}
v &= 1 / (1 + i), \label{eq:basics-v}\\
a &= D i / (1 - v^n), \label{eq:basics-a}\\
U_{t + 1} &= a (1 - v^{n - t}), \label{eq:basics-U}\\
M_{t + 1} &= a (1 - v^{n - t}), \label{eq:basics-M}\\
D_{t} &= D - \sum_{i < t} M_i. \label{eq:basics-D}
\end{align}

Spočítat výši anuity a vývoj úrokové platby, úmoru a zbývajícího dluhu znamená jen přepsat matematické výrazy do R~kódu. Zkuste nejprve následující kód zapsat přímo do konzoly. Zjistíte, že to není právě pohodlné. Pokud uděláte chybu, nemusíte přesně vědět, odkud začít: pokud např.~na řádku \texttt{Dz\ \textless{}-\ D\ -\ cumsum(M)} napíšete omylem \texttt{D} místo \texttt{Dz}, přepíšete si původní hodnotu. A~pokud se nakonec rozhodnete změnit výši dluhu např.~na 1~milion, budete muset všechny řádky spustit ručně znovu. Pokud však kód napíšete do skriptu, můžete kdykoli cokoli opravit, a~to včetně výše dluhu, úrokové sazby nebo počtu období (vyzkoušejte si to).

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# vyčisti pracovní prostředí}
\FunctionTok{rm}\NormalTok{(}\AttributeTok{list =} \FunctionTok{ls}\NormalTok{())}
\CommentTok{\# načti potřebné balíky}
\FunctionTok{library}\NormalTok{(ggplot2)}
\FunctionTok{library}\NormalTok{(tidyr)}
\CommentTok{\# zadej konstanty}
\NormalTok{D }\OtherTok{\textless{}{-}} \DecValTok{40000}  \CommentTok{\# výše dluhu}
\NormalTok{i }\OtherTok{\textless{}{-}} \DecValTok{12} \SpecialCharTok{/} \DecValTok{100}  \CommentTok{\# úroková sazba}
\NormalTok{n }\OtherTok{\textless{}{-}} \DecValTok{6}  \CommentTok{\# počet období}
\CommentTok{\# vlastní výpočet}
\NormalTok{t }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\NormalTok{n  }\CommentTok{\# vektor času}
\NormalTok{v }\OtherTok{\textless{}{-}} \DecValTok{1} \SpecialCharTok{/}\NormalTok{ (}\DecValTok{1} \SpecialCharTok{+}\NormalTok{ i)  }\CommentTok{\# diskontní faktor}
\NormalTok{a }\OtherTok{\textless{}{-}}\NormalTok{ D }\SpecialCharTok{*}\NormalTok{ i }\SpecialCharTok{/}\NormalTok{ (}\DecValTok{1} \SpecialCharTok{{-}}\NormalTok{ v }\SpecialCharTok{\^{}}\NormalTok{ n)  }\CommentTok{\# anuita}
\NormalTok{U }\OtherTok{\textless{}{-}}\NormalTok{ a }\SpecialCharTok{*}\NormalTok{ (}\DecValTok{1} \SpecialCharTok{{-}}\NormalTok{ v }\SpecialCharTok{\^{}}\NormalTok{ (n }\SpecialCharTok{{-}}\NormalTok{ t }\SpecialCharTok{+} \DecValTok{1}\NormalTok{))  }\CommentTok{\# vektor úrokových plateb v čase t}
\NormalTok{M }\OtherTok{\textless{}{-}}\NormalTok{ a }\SpecialCharTok{*}\NormalTok{ v }\SpecialCharTok{\^{}}\NormalTok{ (n }\SpecialCharTok{{-}}\NormalTok{ t }\SpecialCharTok{+} \DecValTok{1}\NormalTok{)  }\CommentTok{\# vektor úmorů v čase t}
\NormalTok{Dz }\OtherTok{\textless{}{-}}\NormalTok{ D }\SpecialCharTok{{-}} \FunctionTok{cumsum}\NormalTok{(M)  }\CommentTok{\# vektor zbývajícího dluhu v čase t}
\NormalTok{df }\OtherTok{\textless{}{-}} \FunctionTok{round}\NormalTok{(}\FunctionTok{data.frame}\NormalTok{(}\AttributeTok{t =}\NormalTok{ t, }\AttributeTok{U =}\NormalTok{ U, }\AttributeTok{M =}\NormalTok{ M, }\AttributeTok{D =}\NormalTok{ Dz), }\DecValTok{2}\NormalTok{)}
\CommentTok{\# výpis výsledku v tabulce}
\FunctionTok{print}\NormalTok{(df)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   t       U       M        D
## 1 1 4800.00 4929.03 35070.97
## 2 2 4208.52 5520.51 29550.46
## 3 3 3546.06 6182.97 23367.49
## 4 4 2804.10 6924.93 16442.55
## 5 5 1973.11 7755.92  8686.63
## 6 6 1042.40 8686.63     0.00
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# vykreslení vývoje veličin do grafu}
\FunctionTok{ggplot}\NormalTok{(}\FunctionTok{gather}\NormalTok{(df, proměnná, hodnota, }\SpecialCharTok{{-}}\NormalTok{t),}
       \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ t, }\AttributeTok{y =}\NormalTok{ hodnota, }\AttributeTok{color =}\NormalTok{ proměnná)) }\SpecialCharTok{+}
    \FunctionTok{geom\_line}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{xlab}\NormalTok{(}\StringTok{"čas"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{basics_files/figure-latex/unnamed-chunk-19-1.pdf}

Všimněte si, že ve skriptu načítáme všechny potřebné balíky, ale neinstalujeme je!

\hypertarget{jak-se-r-uux10dit}{%
\section{Jak se R učit}\label{jak-se-r-uux10dit}}

Nakonec několik rad, jak se učit s~R pracovat.

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\item
  Nesnažte se zapamatovat všechny detaily volání každé funkce~-- to snadno najdete v~dokumentaci. Snažte se spíše pochopit princip, jak věci fungují.
\item
  Naučte se číst dokumentaci funkcí~-- a~skutečně ji čtěte. Když narazíte na neznámou funkci, přečtěte si pozorně dokumentaci a vyzkoušejte příklady na jejím konci.
\item
  Hrajte si a zkoušejte věci. Vymyslete si vlastní problém a zkuste jej vyřešit.
\item
  Ke kódu přistupujte ``experimentálně''. Pokud nevíte, jak něco funguje, vytvořte si hypotézu a vymyslete experiment, jak ji ověřit. Vždy přemýšlejte, jak a proč něco funguje.
\item
  Zkoušejte příklady, na které narazíte. Kód z~příkladů raději opište než kopírujte \texttt{Ctrl-C\ Ctrl-V}. Když kód opíšete, něco si tím zapamatujete. Než kód spustíte, odhadněte, co udělá, a~proč. Pak svůj odhad porovnejte se skutečností.
\item
  Až se naučíte základy, zkuste číst zdrojový kód cizích funkcí, které používáte. Tak se naučíte hodně o~tom, jak pracovat (i~o~tom, co raději nedělat).
\item
  Nepropadejte panice! Zvládnete to.
\item
  Když všechno selže, je tu Google a StackOverflow.
\end{enumerate}

\hypertarget{promux11bnnuxe9}{%
\chapter{Proměnné}\label{promux11bnnuxe9}}

Málo kdy pracujeme s~daty přímo jako s~čísly. V~případě velkých dat by to ani nebylo možné. Místo toho svá data uložíme do proměnných a dále pracujeme s~těmito proměnnými. Kromě usnadnění práce to má ještě jednu výhodu: naše skripty jsou tak obecnější. Můžeme např.~napsat analytický kód s~pomocí dat z~pilotního průzkumu, a~pak jej spustit znovu ve chvíli, kdy doběhl celý sběr dat, s~novými daty. Vyměníme jen datový soubor a jinak nemusíme svůj kód vůbec měnit.

V~této kapitole se naučíte

\begin{itemize}
\tightlist
\item
  co jsou proměnné a k~čemu slouží
\item
  jaká jména proměnných jsou povolená (a~jak tuto restrikci obejít)
\item
  jak přiřadit do proměnné hodnotu
\item
  jak vypsat obsah proměnné
\item
  jak proměnnou smazat
\item
  jak zjistit, jaká metadata proměnná obsahuje, a~jak je změnit
\end{itemize}

\hypertarget{k-ux10demu-slouux17euxed-promux11bnnuxe9}{%
\section{K čemu slouží proměnné}\label{k-ux10demu-slouux17euxed-promux11bnnuxe9}}

Koncept proměnné znáte z~matematiky. Tam je proměnná ``krycí název'' pro nějakou hodnotu, např.~pro číslo~5. Krása proměnných spočívá v~tom, že umožňují počítat zcela obecně. Pokud např.~označíme délku trasy v~kilometrech písmenem~\(s\) a rychlost jízdy v~kilometrech za hodinu písmenem~\(v\), pak víme, že vzdálenost~\(s\) ujedeme za \(s/v\) hodin. Tento výsledek platí bez ohledu na to, jak daleko a jak rychle jedeme. Jak už naznačuje název proměnná, můžeme hodnotu proměnné měnit, a~výraz \(s/v\) vyhodnotit pokaždé znovu. Pro jednoduchý výpočet, který jsme právě uvažovali, nemusí být takové zobecnění příliš užitečné, ale při složitých výpočtech nad velkými daty je zavedení proměnných velká pomoc. V~počítači plní proměnné stejnou úlohu jako v~matematice: uchovávají nějakou hodnotu. Můžeme počítači říct, co má s~touto hodnotou dělat, bez toho, abychom přesně věděli, jaká tato hodnota je.

I~když to technicky není přesné, můžeme si proměnnou představit jako krabičku, do které se vloží nějaká hodnota. Každá proměnná může v~jednom okamžiku obsahovat vždy jen jednu hodnotu. Pokud do proměnné uložíme novou hodnotu, stará hodnota se ztratí. Slovo ``hodnota'' je však třeba brát volně: ``hodnota'' může být stejně dobře jedno číslo jako složitá struktura složená z~čísel, textů a jiných objektů. (Technicky přesnější je říct, že proměnná jméno, které se odkazuje na nějakou oblast v~paměti počítače, kde jsou uložena naše data. Aby počítač věděl, jak s~daným kusem paměti zacházet, musí vědět, jakého typu jsou uložená data, např.~zda se jedná o~celá čísla nebo o~text, a~v~jaké datové struktuře jsou data uložena, např.~ve vektoru.) R~je volně typovaný jazyk. To znamená, že typ proměnné nemusíte nijak deklarovat a R~jej samo odhadne podle vložené hodnoty. Do proměnné můžete v~jedné chvíli uložit číslo a později toto číslo nahradit třeba kusem textu. R~si s~tím poradí. (Proměnná bude prostě nejdříve odkazovat na jedno místo v~paměti, a~pak na jiné. Nepoužívanou oblast paměti R samo uvolní.)

\hypertarget{sec:variables-names}{%
\section{Jména proměnných}\label{sec:variables-names}}

Jména proměnných musí splňovat určité vlastnosti. Jméno proměnné se může skládat jen z~písmen, číslic, teček a podtržítek a musí začínat písmenem nebo tečkou, za kterou nenásleduje číslice. Jména \texttt{a}, \texttt{a2}, \texttt{myNumber}, \texttt{my\_number}, nebo \texttt{.my.way} jsou přípustná; jména jako \texttt{2way}, \texttt{.2way} nebo \texttt{my-number} nejsou povolená. Stejně tak nejsou povolená rezervovaná slova: \texttt{if}, \texttt{else}, \texttt{repeat}, \texttt{while}, \texttt{function}, \texttt{for}, \texttt{in}, \texttt{next}, \texttt{break}, \texttt{TRUE}, \texttt{FALSE}, \texttt{NULL}, \texttt{Inf}, \texttt{NaN}, \texttt{NA}, \texttt{NA\_integer\_}, \texttt{NA\_real\_}, \texttt{NA\_complex\_} a \texttt{NA\_character\_}. Ve jménech proměnných záleží na velikosti písmenem, takže \texttt{x} a \texttt{X} jsou dvě různé proměnné.

Jméno proměnné by ideálně mělo být stručné a mělo by výstižně popisovat, jakou hodnotu proměnná obsahuje. Pokud se jméno skládá z~více slov, slova se historicky oddělovala tečkami (např.~\texttt{pv.of.bond}). V~současné době se to nedoporučuje, protože tečky se používají i~k~oddělení generické a specifické části jmen objektových metod, viz kapitola~\ref{kap:objekty}. Místo toho se doporučuje používat podtržítka (\texttt{pv\_of\_bond}) nebo případně tzv.~``Camel Case'' standard (\texttt{pvOfBond}), který však v~R~není příliš obvyklý.

Pokud si nejste jistí, jak jméno proměnné sestavit, může vám pomoci funkce \texttt{make.names()}, která převede zadaný řetězec na syntakticky platné jméno proměnné, ovšem bohužel s~tečkami:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{make.names}\NormalTok{(}\StringTok{"pv of bond"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "pv.of.bond"
\end{verbatim}

Někdy je potřeba pracovat s~proměnnou, jejíž jméno není v~R povoleno. (Taková situace nejčastěji vznikne při importu dat z~jiného softwaru.) Proměnnou s~nelegálním jménem můžete použít, pokud její jméno uzavřete mezi dva zpětné apostrofy (``backticks''). Jméno proměnné nemůže obsahovat (mimo jiné) mezeru. Pomocí zpětných apostrofů však můžete pracovat i~s~proměnnou, jejíž jméno mezeru obsahuje:

\begin{Shaded}
\begin{Highlighting}[]
\StringTok{\textasciigrave{}}\AttributeTok{ahoj lidičky!}\StringTok{\textasciigrave{}} \OtherTok{\textless{}{-}} \DecValTok{5}
\DecValTok{2} \SpecialCharTok{*} \StringTok{\textasciigrave{}}\AttributeTok{ahoj lidičky!}\StringTok{\textasciigrave{}}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 10
\end{verbatim}

I~když je možné používat i~``nedovolená'' jména proměnných, výrazně to nedoporučujeme.

\hypertarget{pux159iux159azenuxed-hodnoty-do-promux11bnnuxe9}{%
\section{Přiřazení hodnoty do proměnné}\label{pux159iux159azenuxed-hodnoty-do-promux11bnnuxe9}}

Hodnoty se do proměnných přiřazují pomocí ``šipky'' \texttt{\textless{}-}, kde šipka vždy ukazuje ke jménu proměnné, zatímco na druhé straně je výraz, který má R vyhodnotit. V~RStudiu lze šipku vložit pomocí klávesové zkratky \texttt{Alt-}. (Funguje i~šipka~\texttt{-\textgreater{}} otočená opačným směrem. Tuto kuriozitu však používá jen p.~Mikula a výrazně vám nedoporučuji ji používat, protože při čtení kódu zjistíte, co se s~daným výrazem stane, až na konci možná velmi dlouhé konstrukce.)
Někteří lidé používají k~přiřazení do proměnné i~symbol rovnítka (\texttt{=}). To nedoporučuji. Rovnítko v~některých kontextech funguje jako synonymum šipky, zatímco v~jiných ne (tam rovnítko znamená něco jiného). Použití rovnítka k~přiřazení je tak matoucí. Detaily najdete na \url{https://goo.gl/Tnu8Q5}.

Příklad:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}}\NormalTok{ (}\DecValTok{2} \SpecialCharTok{+} \DecValTok{3}\NormalTok{) }\SpecialCharTok{*} \DecValTok{4}  \CommentTok{\# x má nyní hodnotu 20}
\NormalTok{x  }\CommentTok{\# jak se vzápětí přesvědčíme}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 20
\end{verbatim}

\hypertarget{vypsuxe1nuxed-hodnoty-promux11bnnuxe9-do-konzoly}{%
\section{Vypsání hodnoty proměnné do konzoly}\label{vypsuxe1nuxed-hodnoty-promux11bnnuxe9-do-konzoly}}

Při přiřazení hodnoty do proměnné se výsledek nevypíše. Pokud jej chcete vypsat, musíte o~to R požádat. To můžete udělat třemi způsoby: 1)~explicitně vypsat obsah proměnné pomocí funkce \texttt{print()}, 2)~implicitně vypsat obsah proměnné tak, že napíšete její jméno do konzoly (R~volá implicitně funkci \texttt{print()} za vás) nebo 3)~tak, že celý výraz přiřazení zabalíte do závorek.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \StringTok{"This is some text."}  \CommentTok{\# hodnota se přiřadí, nic se nevypíše}
\NormalTok{x         }\CommentTok{\# implicitní vypsání hodnoty proměnné x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "This is some text."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(x)  }\CommentTok{\# explicitní vypsání hodnoty proměnné x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "This is some text."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{(y }\OtherTok{\textless{}{-}} \DecValTok{2}\NormalTok{)  }\CommentTok{\# výraz se vyhodnotí a hodnota implicitně vypíše }
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2
\end{verbatim}

Implicitní forma vypsání obsahu proměnné je vhodná pro interaktivní práci v~konzoli, nemusí však fungovat uvnitř funkcí a skriptů, protože ve skutečnosti jen žádáte R o~vrácení hodnoty proměnné. Podle kontextu může být vrácená proměnná využita různě. V~konzoli se využije tak, že konzola na hodnotu zavolá funkci \texttt{print()}. Uvnitř funkce však může být vrácená hodnota použitá funkcí jinak. Uvnitř funkcí a podobných struktur je tedy třeba obsah proměnné vypsat explicitně pomocí funkce \texttt{print()}.

To, jak R vypíše obsah proměnné, se může lišit od skutečného obsahu dané proměnné. R~totiž pro různé objekty volá různé varianty funkce \texttt{print()} přizpůsobené těmto objektům a může vypsat více nebo méně informací, než je jich v~dané proměnné obsaženo. To, jak vypisuje data pro základní datové typy a struktury se dozvíte v~následujících dvou kapitolách.

Někdy proměnná obsahuje mnoho hodnot (např.~dlouhý vektor, tabulku s~mnoha řádku apod.) a my ji nechceme vypsat celou, nýbrž z~ní chceme získat jen nějakou ukázku, typicky několik prvních nebo posledních hodnot. Několik prvních hodnot vrací funkce \texttt{head()}, posledních hodnot funkce \texttt{tail()}. Obě vrací implicitně 6~hodnot (prvků vektoru, řádků matice apod.); tento počet lze změnit nastavením parametru~\texttt{n}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{1200}\NormalTok{, }\AttributeTok{ncol =} \DecValTok{3}\NormalTok{)  }\CommentTok{\# vytvoří matici se 400 řádky}
\FunctionTok{head}\NormalTok{(x)                        }\CommentTok{\# vypíše 6 prvních řádků matice}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3]
## [1,]    1  401  801
## [2,]    2  402  802
## [3,]    3  403  803
## [4,]    4  404  804
## [5,]    5  405  805
## [6,]    6  406  806
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{head}\NormalTok{(x, }\AttributeTok{n =} \DecValTok{3}\NormalTok{)                 }\CommentTok{\# vypíše 3 první řádky matice}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3]
## [1,]    1  401  801
## [2,]    2  402  802
## [3,]    3  403  803
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{tail}\NormalTok{(x)                        }\CommentTok{\# vypíše 6 posledních řádků matice}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##        [,1] [,2] [,3]
## [395,]  395  795 1195
## [396,]  396  796 1196
## [397,]  397  797 1197
## [398,]  398  798 1198
## [399,]  399  799 1199
## [400,]  400  800 1200
\end{verbatim}

Pokud pracujete v~RStudiu, můžete použít k~zobrazení obsahu proměnné i~funkci \texttt{View()}. Tato funkce otevře novou záložku a zobrazí obsah proměnné. Způsob zobrazení závisí na datové struktuře. Atomické vektory, matice a tabulky zobrazí ve formě interaktivní tabulky, která umožňuje hodnoty třídit a filtrovat. Seznamy a objekty postavené nad seznamy se zobrazí podobně, jako je vypisuje funkce \texttt{str()}. Funkci \texttt{View()} je možné vyvolat i~pomocí myši tak, že v~záložce \texttt{Environment} kliknete na ikonku tabulky (tabulární pohled) nebo trojúhelníku vedle jména proměnné. Pozor: seznam proměnných musí být v~režimu ``List''.

\hypertarget{atributy-metadata}{%
\section{Atributy (metadata)}\label{atributy-metadata}}

Proměnné v~R obsahují kromě vlastních hodnot také metadata (informace o~datech). V~R se metadata nazývají atributy.

Funkce \texttt{attributes()} vypíše seznam všech atributů dané proměnné.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\AttributeTok{a =} \DecValTok{1}\NormalTok{, }\AttributeTok{b =} \DecValTok{2}\NormalTok{, }\AttributeTok{c =} \DecValTok{3}\NormalTok{)  }\CommentTok{\# vektor s pojmenovanými prvky}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## a b c 
## 1 2 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{attributes}\NormalTok{(x)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $names
## [1] "a" "b" "c"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{X }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)  }\CommentTok{\# matice má počet řádků a sloupců}
\NormalTok{X}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{attributes}\NormalTok{(X)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $dim
## [1] 3 4
\end{verbatim}

Atributy proměnných mohou zahrnovat třídu objektu, dimenze proměnných (počet řádků, sloupců a případně dalších rozměrů objektu), jména řádků, sloupců, jednotlivých prvků vektorů a případně další informace.

Hodnotu jednoho atributu je možné získat funkcí \texttt{attr()}; tuto funkci je zároveň možné použít i~ke změně hodnoty atributu (ve skutečnosti se volá jiná funkce, syntaxe však vypadá stejně):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{attr}\NormalTok{(x, }\StringTok{"names"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "a" "b" "c"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{attr}\NormalTok{(x, }\StringTok{"names"}\NormalTok{) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"Ahoj"}\NormalTok{, }\StringTok{"Bum"}\NormalTok{, }\StringTok{"Cak"}\NormalTok{)}
\FunctionTok{attr}\NormalTok{(x, }\StringTok{"names"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Ahoj" "Bum"  "Cak"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Ahoj  Bum  Cak 
##    1    2    3
\end{verbatim}

Pokud se zeptáte na hodnotu atributu, který není v~proměnné přítomen, funkce \texttt{attr()} vrací hodnotu \texttt{NULL}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{attr}\NormalTok{(x, }\StringTok{"coriandr"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## NULL
\end{verbatim}

Atribut zrušíte tak, že do něj přiřadíte hodnotu \texttt{NULL}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{attr}\NormalTok{(x, }\StringTok{"names"}\NormalTok{) }\OtherTok{\textless{}{-}} \ConstantTok{NULL}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3
\end{verbatim}

\hypertarget{smazuxe1nuxed-promux11bnnuxe9}{%
\section{Smazání proměnné}\label{smazuxe1nuxed-promux11bnnuxe9}}

Ke smazání proměnné z~aktuálního prostředí slouží funkce \texttt{rm()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{rm}\NormalTok{(x)  }\CommentTok{\# smaže proměnnou x}
\FunctionTok{rm}\NormalTok{(x, y, z)  }\CommentTok{\# smaže proměnné x, y a z}
\FunctionTok{rm}\NormalTok{(}\AttributeTok{list =} \FunctionTok{ls}\NormalTok{())  }\CommentTok{\# smaže všechny proměnné z aktuálního prostředí}
\end{Highlighting}
\end{Shaded}

V~RStudiu můžete proměnné mazat i~myší. V~záložce \texttt{Environment} k~tomu slouží ikonka koštěte. Pokud máte proměnné zobrazené v~režimu \texttt{Grid}, můžete vybrat, které proměnné budou smazány. V~režimu \texttt{List} budou smazány všechny proměnné.

Někdy je však potřeba vyčistit paměť~R důkladněji. Smazání všech proměnných totiž stále zanechá v~R mnoho změn: načtené balíky, změněné cesty apod. Nejdůkladnější vyčištění pracovního prostředí přestavuje restart~R. V~RStudiu je to možné udělat v~menu \texttt{Session}\(\rightarrow\)\texttt{Restart\ R} nebo pomocí klávesové zkratky \texttt{Ctrl}-\texttt{Shift}-\texttt{F10}. Pokud si chcete ověřit, že váš skript běží spolehlivě, vždy byste jej měli vyzkoušet v~čistém prostředí~R, tj.~po jeho restartu.

\hypertarget{aplikace-vuxfdpoux10det-dojezdovuxe9-vzduxe1lenosti}{%
\section{Aplikace: výpočet dojezdové vzdálenosti}\label{aplikace-vuxfdpoux10det-dojezdovuxe9-vzduxe1lenosti}}

Jako příklad práce s~proměnnými vytvoříme jednoduchý skript, který spočítá, za jak dlouho dorazíme do cíle. Nejdříve si vyčistíme pracovní prostředí smazáním všech dříve vytvořených proměnných (což je velmi užitečný zvyk). Následně vytvoříme proměnné vzdálenost a rychlost, pak vypočteme dobu jízdy a vypíšeme ji. Náš skript bude tedy vypadat takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{rm}\NormalTok{(}\AttributeTok{list =} \FunctionTok{ls}\NormalTok{())}
\NormalTok{vzdalenost }\OtherTok{\textless{}{-}} \DecValTok{1079}  \CommentTok{\# vzdálenost z Brna do Dubrovniku v km}
\NormalTok{rychlost }\OtherTok{\textless{}{-}} \DecValTok{90}  \CommentTok{\# očekávaná průměrná rychlost v km / h}
\NormalTok{doba\_jizdy }\OtherTok{\textless{}{-}}\NormalTok{ vzdalenost }\SpecialCharTok{/}\NormalTok{ rychlost}
\FunctionTok{print}\NormalTok{(doba\_jizdy)}
\end{Highlighting}
\end{Shaded}

Pokud jste svůj skript napsali do nového okna editoru v~RStudiu, spustíte jej jednoduše stisknutím tlačítka \texttt{Source}. Výsledkem by mělo být, že pojedete necelých 12~hodin. To byste mohli mnohem jednodušeji zjistit i~s~pomocí obyčejné kalkulačky. Skript vám však umožní zjistit i~to, co se stane, pokud pojedete rychleji nebo pomaleji: stačí jen změnit rychlost na třetím řádku a skript spustit znovu. Podobně můžete změnit i~vzdálenost na druhém řádku a zjistit, jak dlouho pojedete do jiné destinace. (V~kapitole~\ref{kap:funkce} se naučíte proces, který vám umožní snadno měnit parametry výpočtu jako jsou rychlost a vzdálenost ještě více automatizovat pomocí tvorby vlastních funkcí.)

\hypertarget{zuxe1kladnuxed-datovuxe9-typy}{%
\chapter{Základní datové typy}\label{zuxe1kladnuxed-datovuxe9-typy}}

Každá hodnota uložená v~proměnné má nějaký datový typ. Abyste porozuměli chování~R, musíte se s~vlastnostmi a možnostmi jednotlivých datových typů seznámit.

V~této kapitole se naučíte

\begin{itemize}
\tightlist
\item
  jaké jsou základní datové typy používané v~datové analýze
\item
  jaký je význam speciálních hodnot \texttt{NA}, \texttt{NaN}, \texttt{Inf} a \texttt{NULL}
\item
  jak poznáte, jakého typu je která hodnota
\item
  jak je možné převádět data z~jednoho typu na druhý
\item
  jak používat základní aritmetické a logické operátory
\end{itemize}

\hypertarget{zuxe1kladnuxed-datovuxe9-typy-1}{%
\section{Základní datové typy}\label{zuxe1kladnuxed-datovuxe9-typy-1}}

Data se skládají z~jednotlivých hodnot. Každá taková hodnota má určitý datový typ. V~R~existuje mnoho základních typů dat. Pro datovou analýzu se však hodí především následující čtyři datové typy:

\begin{itemize}
\tightlist
\item
  \textbf{logical} může obsahovat jen dvě logické hodnoty: \texttt{TRUE} (``pravda'') a \texttt{FALSE} (``nepravda''). Tyto hodnoty je možné zkrátit na \texttt{T} a \texttt{F}, ale výrazně se to nedoporučuje, protože zkrácená jména~\texttt{T} a \texttt{F} je možné předefinovat, po čemž by původně funkční kód dělal nepředvídatelné věci.
\item
  \textbf{integer} může obsahovat kladná i záporná celá čísla. Pokud je chcete zadat, musíte za číslo napsal~\texttt{L}, tj.~např.~\texttt{1L}.
\item
  \textbf{double} může obsahovat kladná i záporná reálná čísla. Když zadáte v~konzoli nebo skriptu číslo bez příznaku~\texttt{L}, bude v~paměti reprezentované jako double, i~když to bude shodou okolností celé číslo. V~konzoli však R vypíše celá čísla inteligentně bez desetinných míst, i~když jsou uložená v~proměnné typu \emph{double}.
\item
  \textbf{character} může obsahovat libovolný řetězec (text). V~R se řetězce zadávají mezi dvěma uvozovkami nebo apostrofy. Uvozovky a apostrofy nelze kombinovat, tj.~nejde jeden řetězec uvést uvozovkou a ukončit apostrofem. To umožňuje zadat apostrofy nebo uvozovky jako součást řetězce tak, že je např.~řetězec uvozen i~ukončen uvozovkami a uvnitř řetězce je použit apostrof. Jinou možností, jak zadat uvozovky, apostrofy a jiné zvláštní znaky, je ``escapovat'' je, tj.~napsat je pomocí zpětného lomítka \texttt{\textbackslash{}} a vybraného znaku (např.~\texttt{\textbackslash{}"}~znamená uvozovku, \texttt{\textbackslash{}n}~konec řádku apod.).
\end{itemize}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x1 }\OtherTok{\textless{}{-}} \ConstantTok{TRUE}  \CommentTok{\# logická hodnota}
\NormalTok{x1}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x2 }\OtherTok{\textless{}{-}}\NormalTok{ 1L  }\CommentTok{\# celé číslo}
\NormalTok{x2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x3 }\OtherTok{\textless{}{-}} \DecValTok{1}  \CommentTok{\# reálné číslo}
\NormalTok{x3}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x4 }\OtherTok{\textless{}{-}} \StringTok{\textquotesingle{}Josef řekl: "Miluji R!"\textquotesingle{}}  \CommentTok{\# řetězec}
\NormalTok{x4}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Josef řekl: \"Miluji R!\""
\end{verbatim}

Při zadávání reálných čísel se desetinná místa oddělují \emph{tečkou}, ne čárkou.

\begin{Shaded}
\begin{Highlighting}[]
\FloatTok{1.3}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1.3
\end{verbatim}

Čárky oddělují parametry ve funkcích~-- jinde způsobí chybovou hlášku!

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{1}\NormalTok{,}\DecValTok{3}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: <text>:1:2: unexpected ','
## 1: 1,
##      ^
\end{verbatim}

Reálná čísla jde zadat i~pomocí tzv.~``vědecké notace'', kde číslo před \texttt{e} je mantisa, číslo za \texttt{e} dekadický exponent:

\begin{Shaded}
\begin{Highlighting}[]
\FloatTok{1.3e3}   \CommentTok{\# 1.3 krát 10 na třetí, tj. 1 300}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1300
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FloatTok{2.7e{-}5}  \CommentTok{\# 2.7 krát 10 na minus pátou, tj. 0.000027}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2.7e-05
\end{verbatim}

R~někdy reálná čísla takto samo vypisuje. Pokud chcete ovlivnit, jak bude reálné číslo vypsané, můžete použít funkci \texttt{format()} (víc parametrů viz nápověda funkce):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{format}\NormalTok{(}\FloatTok{2.7e{-}5}\NormalTok{, }\AttributeTok{scientific =} \ConstantTok{FALSE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "0.000027"
\end{verbatim}

Mezi proměnnou typu \emph{integer} a \emph{double} je několik rozdílů. Hlavní z~nich se týká přesnosti: typ \emph{integer} sice umí zahrnout jen celá čísla, reprezentuje je však naprosto přesně. Naproti tomu typ \emph{double} umí zahrnout i~desetinná čísla (a~také velmi velká čísla), reprezentuje je však pouze přibližně, takže v~následujícím výpočtu vznikne chyba, i~když velmi malá:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{sqrt}\NormalTok{(}\DecValTok{2}\NormalTok{) }\SpecialCharTok{\^{}} \DecValTok{2} \SpecialCharTok{{-}} \DecValTok{2}  \CommentTok{\# odmocnina 2 umocněná na druhou minus 2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4.440892e-16
\end{verbatim}

\hypertarget{testovuxe1nuxed-datovuxe9ho-typu}{%
\section{Testování datového typu}\label{testovuxe1nuxed-datovuxe9ho-typu}}

R umožňuje otestovat, jaký datový typ má zvolená proměnná, pomocí funkcí \texttt{is.X()}, kde \texttt{X} je daný datový typ. Tyto funkce vrací \texttt{TRUE}, pokud je daná proměnná daného datového typu. Existuje i~funkce \texttt{is.numeric()}, která vrací hodnotu \texttt{TRUE} v~případě, že proměnná je číselná, ať už celočíselná nebo reálná.

Funkce \texttt{typeof()} vrací datový typ proměnné jako řetězec (např.~\texttt{"logical"}). Podobná, ale zdaleka ne stejná, je funkce \texttt{class()}, která vrací třídu objektu z~hlediska objektově orientovaného programování. Pro atomické vektory však vrací typ proměnných.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{typeof}\NormalTok{(x1)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "logical"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.logical}\NormalTok{(x1)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.numeric}\NormalTok{(x1)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{typeof}\NormalTok{(x2)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "integer"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.integer}\NormalTok{(x2)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.numeric}\NormalTok{(x2)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{typeof}\NormalTok{(x3)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "double"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.integer}\NormalTok{(x3)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.double}\NormalTok{(x3)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.numeric}\NormalTok{(x3)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{typeof}\NormalTok{(x4)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "character"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.character}\NormalTok{(x4)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Podobné, ale poněkud přísněji se chovající testy nabízí balík \textbf{purrr}, např.:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{purrr}\SpecialCharTok{::}\FunctionTok{is\_integer}\NormalTok{(x1)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

\hypertarget{chybux11bjuxedcuxed-a-divnuxe9-hodnoty}{%
\section{Chybějící a ``divné'' hodnoty}\label{chybux11bjuxedcuxed-a-divnuxe9-hodnoty}}

V~některých případech může proměnná obsahovat příznak, že její hodnota chybí nebo je chybná. R~k~tomu má tři speciální hodnoty:

\begin{itemize}
\tightlist
\item
  \texttt{NA} je chybějící hodnota (``not available''). Existuje pro všechny základní datové typy.
\item
  \texttt{NaN} znamená, že numerická hodnota není číslo, ale je chybná (``not a number''). Tato hodnota existuje jen pro typ \emph{double}.
\item
  \texttt{Inf} označuje nekonečnou hodnotu; podobně \texttt{-Inf} zápornou nekonečnou hodnotu. Obě hodnoty také existují jen pro typ \emph{double}.
\end{itemize}

Nekonečná hodnota vznikne např.~při dělení nenulového čísla nulou:

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{1} \SpecialCharTok{/} \DecValTok{0}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] Inf
\end{verbatim}

Chybná hodnota vznikne při různých nepovolených matematických operacích, které však nevedou na nekonečno, např. při dělení nuly nulou:

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{0} \SpecialCharTok{/} \DecValTok{0}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] NaN
\end{verbatim}

Chybějící hodnoty~\texttt{NA} se obvykle používají při zadávání hodnot v~konzoli nebo ve skriptu a při ukládání čísel do souboru, aby se označilo, která hodnota chybí. Mohou však také být výsledkem výpočtu, když danou operaci není možné provést, ale nejedná se při tom o~neplatné počítání s~čísly, které by vedlo na \texttt{Inf} nebo \texttt{NaN}.

Existují testy, které testují, zda je hodnota proměnné \texttt{NA}, \texttt{NaN} nebo \texttt{Inf}, a~které vracejí jako výsledek logickou hodnotu testu \texttt{TRUE} nebo \texttt{FALSE}: \texttt{is.na()}, \texttt{is.nan()}, \texttt{is.finite()} a \texttt{is.infinite()}. Funkce \texttt{is.infinite()} vrací \texttt{TRUE} jak pro \texttt{Inf}, tak i~pro \texttt{-Inf}; funkce \texttt{is.finite()} naopak. Pozor: funkce \texttt{is.na()} vrací \texttt{TRUE} jak pro \texttt{NA}, tak i~pro \texttt{NaN}.

Stejně jako ostatní hodnoty v~R, tak i chybějící hodnoty mají svůj typ. V~celočíselné proměnné je tak \texttt{NA} ve skutečnosti reprezentované jako \texttt{NA\_integer\_}, zatímco v~reálné proměnné jako \texttt{NA\_real\_} apod. Pokud byste vypsali obsah těchto dvou proměnných na obrazovku, uvidíte \texttt{NA}; pokud byste použili k~otestování shody jejich obsahu funkci \texttt{identical()} (viz dále), zjistíte, že hodnoty nejsou stejné:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x1 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(1L, }\ConstantTok{NA}\NormalTok{)[}\DecValTok{2}\NormalTok{]   }\CommentTok{\# vezme se druhá hodnota celočíselného vektoru}
\NormalTok{x2 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\ConstantTok{NA}\NormalTok{)[}\DecValTok{2}\NormalTok{]    }\CommentTok{\# vezme se druhá hodnota reálného vektoru}
\NormalTok{x1}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] NA
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] NA
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{identical}\NormalTok{(x1, x2)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

Velmi speciální hodnotou je \texttt{NULL}. \texttt{NULL} je speciální objekt (má vlastní datový typ) a zároveň rezervované slovo, které R vrací v~situaci, kdy nějaká hodnota není definovaná nebo nějaký vektor neexistuje. \texttt{NULL} se často chová jako vektor nulové délky. K~otestování, zda je hodnota objektu \texttt{NULL} slouží funkce \texttt{is.null()}.

\hypertarget{pux159evody-mezi-datovuxfdmi-typy}{%
\section{Převody mezi datovými typy}\label{pux159evody-mezi-datovuxfdmi-typy}}

V~případě, že R potřebuje nějakým způsobem sladit dva základní datové typy (např.~je spojit do jednoho atomického vektoru), provede R jejich automatickou konverzi a převede jednodušší typ na obecnější typ. Převod probíhá od logických proměnných k~celočíselným (\texttt{TRUE} se převede na~1 a \texttt{FALSE} na~0), od celočíselných k~reálným a od nich k~řetězcům. Při automatické konverzi záleží na pořadí:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# funkce c() spojí hodnoty v závorkách do vektoru a převede je na společný typ}
\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, 1L, }\DecValTok{1}\NormalTok{, }\StringTok{"1"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "TRUE" "1"    "1"    "1"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{c}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, 1L), }\DecValTok{1}\NormalTok{, }\StringTok{"1"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "1" "1" "1" "1"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{c}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, 1L, }\DecValTok{1}\NormalTok{), }\StringTok{"1"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "1" "1" "1" "1"
\end{verbatim}

Automatické konverze lze někdy využít k~zajímavým trikům. Pokud např.~chceme sečíst počet případů, ve kterých platí nějaká podmínka, jde použít na logický vektor numerickou funkci pro součet hodnot prvků vektoru \texttt{sum()} a využít automatickou konverzi:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{7}\NormalTok{, }\DecValTok{19}\NormalTok{, }\DecValTok{31}\NormalTok{)  }\CommentTok{\# vytvoří vektor daných čísel}
\CommentTok{\# kolik hodnot x je větší než 10?}
\FunctionTok{sum}\NormalTok{(x }\SpecialCharTok{\textgreater{}} \DecValTok{10}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2
\end{verbatim}

Výraz \texttt{sum(x\ \textgreater{}\ 10)} se vyhodnotí postupně: nejdříve se vyhodnotí výraz \texttt{x\ \textgreater{}\ 10}, jehož výsledkem je logický vektor, kde je každé číslo větší než 10 nahrazeno \texttt{TRUE} a každé číslo menší rovno~10 nahrazeno \texttt{FALSE}. Ve druhém kroku R automaticky nahradí každé \texttt{TRUE} jedničkou a každé \texttt{FALSE} nulou. Ve třetím kroku sečte vektor jedniček a nul.

V~některých situacích je třeba provést konverzi ručně. K~tomu slouží funkce \texttt{as.X()}, kde \texttt{X} je jméno datového typu.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.character}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "TRUE"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.integer}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.logical}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\SpecialCharTok{{-}}\DecValTok{1}\NormalTok{, }\DecValTok{0}\NormalTok{, }\FloatTok{0.1}\NormalTok{, }\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{5}\NormalTok{))  }\CommentTok{\# nula se převede na FALSE, ostatní čísla na TRUE}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  TRUE FALSE  TRUE  TRUE  TRUE  TRUE
\end{verbatim}

Překvapivě je možné převést i~řetězce na čísla, pokud dané řetězce obsahují číselné hodnoty, nebo na logické hodnoty, pokud je obsahují. Tyto operace však nemusejí být bezpečné.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.integer}\NormalTok{(}\StringTok{"11"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 11
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.double}\NormalTok{(}\StringTok{"11.111"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 11.111
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.logical}\NormalTok{(}\StringTok{"TRUE"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Někdy R neví, jak nějaký objekt převést. Pak je výsledkem hodnota \texttt{NA} a R~vydá varování:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \StringTok{"ahoj"}
\FunctionTok{as.numeric}\NormalTok{(x)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning: NAs introduced by coercion
\end{verbatim}

\begin{verbatim}
## [1] NA
\end{verbatim}

Poznámka: V~R~je zvykem, že objekty má testovací funkci \texttt{is.X} a konverzní funkci \texttt{as.X}. Neplatí to sice vždy, ale valná většina objektů tyto funkce má.

\hypertarget{zuxe1kladnuxed-aritmetickuxe9-operace}{%
\section{Základní aritmetické operace}\label{zuxe1kladnuxed-aritmetickuxe9-operace}}

Základní aritmetické operace jsou sčítání~(\texttt{+}), odčítání~(\texttt{-}), násobení~(\texttt{*}), dělení~(\texttt{/}) a umocňování~(\texttt{\^{}}). K~celočíselnému dělení slouží symbol \texttt{\%/\%}, zbytek po dělení vrací \texttt{\%\%}:

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{1} \SpecialCharTok{+} \DecValTok{2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{3} \SpecialCharTok{*} \DecValTok{4}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{12} \SpecialCharTok{/} \DecValTok{4}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{2} \SpecialCharTok{\^{}} \DecValTok{3}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 8
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{9} \SpecialCharTok{\%/\%} \DecValTok{2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{9} \SpecialCharTok{\%\%} \DecValTok{2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

Operátory mají normální prioritu, na jakou jsme zvyklý z~matematiky, tj.~součin má přednost před sčítáním apod.:

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{1} \SpecialCharTok{+} \DecValTok{2} \SpecialCharTok{*} \DecValTok{3}  \CommentTok{\# 7, nikoli 9}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 7
\end{verbatim}

Pokud potřebujeme změnit pořadí vyhodnocování výrazů, slouží k~tomu stejně jako v~matematice obyčejné kulaté závorky:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{(}\DecValTok{1} \SpecialCharTok{+} \DecValTok{2}\NormalTok{) }\SpecialCharTok{*} \DecValTok{3}  \CommentTok{\# 9, nikoli 7}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 9
\end{verbatim}

\hypertarget{srovnuxe1nuxed-ux10duxedsel}{%
\section{Srovnání čísel}\label{srovnuxe1nuxed-ux10duxedsel}}

Ke srovnání aritmetických hodnot slouží následující operátory: porovnání shody celých čísel (\texttt{==}), různosti celých čísel~(\texttt{!=}), větší~(\texttt{\textless{}}), větší rovno (\texttt{\textless{}=}), menší~(\texttt{\textgreater{}}) a menší rovno (\texttt{\textgreater{}=}). Výsledkem srovnání je logická hodnota \texttt{TRUE} nebo \texttt{FALSE}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1L }\SpecialCharTok{==}\NormalTok{ 3L}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{2L }\SpecialCharTok{==}\NormalTok{ 2L}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1L }\SpecialCharTok{!=}\NormalTok{ 3L}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{1} \SpecialCharTok{\textless{}} \DecValTok{3}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{1} \SpecialCharTok{\textgreater{}} \DecValTok{3}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

Srovnat stejnost nebo různost dvou reálných čísel není pomocí operátorů~\texttt{==} a \texttt{!=} možné. R~sice srovnání provede, ale to nemusí mít žádný smysl, jak ukazuje následující příklad:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x1 }\OtherTok{\textless{}{-}} \FloatTok{0.5} \SpecialCharTok{{-}} \FloatTok{0.3}
\NormalTok{x2 }\OtherTok{\textless{}{-}} \FloatTok{0.3} \SpecialCharTok{{-}} \FloatTok{0.1}
\NormalTok{x1 }\SpecialCharTok{==}\NormalTok{ x2                           }\CommentTok{\# na většině počítačů FALSE}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

Důvod je ten, že necelá čísla, která v~desítkové soustavě vypadají nezáludně, není vždy možné vyjádřit dobře ve dvojkové soustavě a výsledek se proto zaokrouhluje. Proto přestože je výsledek předchozích operací v~desítkové soustavě stejný (1/10), ve dvojkové soustavě dopadne jinak.

Ke srovnání dvou reálných čísel slouží následující fráze:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{identical}\NormalTok{(}\FunctionTok{all.equal}\NormalTok{(x1, x2), }\ConstantTok{TRUE}\NormalTok{) }\CommentTok{\# TRUE všude}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Funkce \texttt{all.equal()} vrací logickou hodnotu \texttt{TRUE}, pokud jsou všechny prvky dvou vektorů stejné; jinak vrací komentář k~velikosti rozdílů. Ovšem ``jsou stejné'' je v~této funkci chápáno volně: dvě reálná čísla jsou stejná, pokud se neliší více než o~několik násobků strojové přesnosti počítače. Funkce \texttt{identical()} vrací logickou hodnotu \texttt{TRUE}, pokud jsou dva objekty identické; jinak vrací \texttt{FALSE}. Dohromady vrátí fráze hodnotu \texttt{TRUE} jen v~případě, kdy jsou obě téměř stejná (až na chybu, která zřejmě vznikla kvůli tomu, jak jsou reálná čísla v~počítači uložená).

Balík \textbf{dplyr} nabízí ke srovnání hodnot typu \emph{double} příjemnou funkci \texttt{near()}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{dplyr}\SpecialCharTok{::}\FunctionTok{near}\NormalTok{(x1, x2)  }\CommentTok{\# TRUE všude}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\hypertarget{sec:data-types-log-oper}{%
\section{Základní logické operace}\label{sec:data-types-log-oper}}

Základní logické operace zahrnují logický součin (``a~zároveň'', \texttt{\&}), logický součet (``nebo'', \texttt{\textbar{}}) a negaci (``opak'', \texttt{!}). Kromě toho samozřejmě fungují i~závorky. Význam jednotlivých operací ukazuje tabulka~\ref{tab:datatype-log-oper}.
Všimněte si, že \texttt{!(V1\ \&\ V2)}~\(=\)~\texttt{!V1\ \textbar{}\ !V2} a \texttt{!(V1\ \textbar{}\ V2)}~\(=\)~\texttt{!V1\ \&\ !V2}.

\begin{longtable}[]{@{}lllllll@{}}
\caption{\label{tab:datatype-log-oper} Význam základních logických operací.}\tabularnewline
\toprule
\texttt{V1} & \texttt{V2} & \texttt{V1\ \&\ V2} & \texttt{V1\ \textbar{}\ V2} & \texttt{!V1} & \texttt{!(V1\ \&\ V2)} & \texttt{!(V1\ \textbar{}\ V2)} \\
\midrule
\endfirsthead
\toprule
\texttt{V1} & \texttt{V2} & \texttt{V1\ \&\ V2} & \texttt{V1\ \textbar{}\ V2} & \texttt{!V1} & \texttt{!(V1\ \&\ V2)} & \texttt{!(V1\ \textbar{}\ V2)} \\
\midrule
\endhead
\texttt{TRUE} & \texttt{TRUE} & \texttt{TRUE} & \texttt{TRUE} & \texttt{FALSE} & \texttt{FALSE} & \texttt{FALSE} \\
\texttt{TRUE} & \texttt{FALSE} & \texttt{FALSE} & \texttt{TRUE} & \texttt{FALSE} & \texttt{TRUE} & \texttt{FALSE} \\
\texttt{FALSE} & \texttt{TRUE} & \texttt{FALSE} & \texttt{TRUE} & \texttt{TRUE} & \texttt{TRUE} & \texttt{FALSE} \\
\texttt{FALSE} & \texttt{FALSE} & \texttt{FALSE} & \texttt{FALSE} & \texttt{TRUE} & \texttt{TRUE} & \texttt{TRUE} \\
\bottomrule
\end{longtable}

Logický součin a součet existují v~R ve dvou formách: jednoduché a ``zkratující''. Ta druhá operátory zdvojuje, takže místo~\texttt{\&} se použije~\texttt{\&\&} a místo \texttt{\textbar{}} se použije \texttt{\textbar{}\textbar{}}. Jednoduchá forma se používá při vyhodnocování operátorů na logických vektorech:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{) }\SpecialCharTok{\&} \FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  TRUE FALSE FALSE FALSE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{) }\SpecialCharTok{|} \FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  TRUE  TRUE  TRUE FALSE
\end{verbatim}

Zkratující forma se používá v~podmínkách, viz oddíl~\ref{sec:if}. V~tomto případě se vyhodnocování výrazu zastaví ve chvíli, kdy je výsledek jednoznačně známý, tj.~např.~ve výrazu

\begin{Shaded}
\begin{Highlighting}[]
\ConstantTok{FALSE} \SpecialCharTok{\&\&} \SpecialCharTok{!}\NormalTok{(}\ConstantTok{TRUE} \SpecialCharTok{||} \ConstantTok{FALSE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

vyhodnocování skončí hned prvním \texttt{FALSE}, protože po jeho vyhodnocení výsledek jasný. Pokud byste použili zkratující formu na vektory, výsledek se bude týkat první položky vektoru:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{) }\SpecialCharTok{\&\&} \FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Vektorová funkce \texttt{all()} vrátí \texttt{TRUE}, pokud jsou všechny prvky vektoru \texttt{TRUE}; jinak vrátí \texttt{FALSE}. Vektorová funkce \texttt{any()} vrátí \texttt{TRUE}, pokud je aspoň jedna hodnota \texttt{TRUE}; jinak vrátí \texttt{FALSE}. (Jedná se tedy o~logický součin a součet přes všechny prvky vektoru.) Funkce \texttt{all.equal()} a \texttt{identical()} byly představeny výše.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{all}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{all}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{any}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{any}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\ConstantTok{FALSE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

\hypertarget{zuxe1kladnuxed-datovuxe9-struktury}{%
\chapter{Základní datové struktury}\label{zuxe1kladnuxed-datovuxe9-struktury}}

Data, která budeme zkoumat, většinou netvoří izolované hodnoty (jednotlivá izolovaná čísla), nýbrž větší množství hodnot, které mají nějaký vztah. Výsledkem ekonomického experimentu může být např.~datový soubor, který obsahuje pro každý subjekt experimentu identifikační číslo daného subjektu, jeho treatment, identifikaci skupiny, do které patřil a seznam akcí, které zahrál, a výplat, kterých dosáhl. Takový datový soubor můžeme zorganizovat jako tabulku, ve které řádky odpovídají jednotlivých subjektům a sloupce jednotlivým proměnným. Pokud jsou všechny proměnné číselné, je tabulka matice. Alternativně můžeme uspořádat každou proměnnou zvlášť jako jednotlivé vektory. V~každém případě však potřebujeme k~uchování hodnot získaných z~experimentu určitý typ datové struktury.

Základní datové struktury, které nám R nabízí, lze roztřídit podle dvou charakteristik: 1)~podle jejich dimensionality na jednorozměrné, dvourozměrné a vícerozměrné objekty a 2)~podle homogenity použitých datových typů na homogenní a heterogenní struktury. Jednotlivé kombinace uvádí tabulka~\ref{tab:datastructure-overview}. Homogenní struktury mají všechny položky stejného typu, např.~celá čísla. Mezi homogenní struktury patří zejména atomické vektory a matice. Heterogenní struktury mohou mít jednotlivé položky různých typů, takže mohou najednou obsahovat např.~reálná čísla i~řetězce. Mezi nejdůležitější heterogenní struktury patří seznamy a různé typy tabulek, jako jsou tabulky tříd \emph{data.frame} a \emph{tibble}. Jednorozměrné datové struktury mají jen jeden rozměr, délku. Sem patří zejména atomické vektory a seznamy (seznamy jsou neatomické vektory). Dvourozměrné struktury mají dva rozměry, takže tvoří tabulku. Nejdůležitější dvourozměrné struktury jsou homogenní matice a nehomogenní tabulky.

\begin{longtable}[]{@{}lll@{}}
\caption{\label{tab:datastructure-overview} Význam základních logických operací.}\tabularnewline
\toprule
dimenze & homogenní & heterogenní \\
\midrule
\endfirsthead
\toprule
dimenze & homogenní & heterogenní \\
\midrule
\endhead
1 & atomický vektor & seznam \\
2 & matice & tabulka \\
více & pole & \(\strut\) \\
\bottomrule
\end{longtable}

V~této kapitole se

\begin{itemize}
\tightlist
\item
  seznámíte se základními datovými strukturami: atomickými vektory, atomickými maticemi, seznamy a tabulkami třídy \emph{data.frame} a \emph{tibble}
\item
  naučíte převádět data z~jedné datové struktury na jinou
\item
  naučíte se získávat podmnožiny (\emph{subsety}) těchto struktur
\item
  dozvíte něco o~tom, jaké struktury volit
\end{itemize}

\hypertarget{atomickuxe9-vektory}{%
\section{Atomické vektory}\label{atomickuxe9-vektory}}

Nejzákladnější datovou strukturou je v~R atomický vektor. R~nemá datovou strukturu pro skalár (jedinou logickou hodnotu, jediné číslo, znak nebo řetězec)~-- každý skalár je ve skutečnosti atomický vektor s~jediným prvkem.
Atomický vektor je vektor hodnot, jehož všechny prvky mají stejný typ (např.~celé číslo). Atomické vektory se vytvářejí funkcí \texttt{c()} (od ``concatenate''), která ``slepí'' jednotlivé hodnoty dohromady, přičemž provede automatickou konverzi (pokud je potřeba).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{17}\NormalTok{)}
\FunctionTok{print}\NormalTok{(x)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  2  3 17
\end{verbatim}

Pomocí funkce \texttt{c()} je možné ``slepit'' i~celé vektory:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x1 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\NormalTok{x2 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{4}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{6}\NormalTok{, }\ConstantTok{NA}\NormalTok{)}
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(x1, x2)}
\FunctionTok{print}\NormalTok{(x)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  2  3  4  5  6 NA
\end{verbatim}

Všechny prvky atomického vektoru musejí mít stejný typ. Pokud tedy při tvorbě atomického vektoru smícháte proměnné různých typů, dojde k~automatické konverzi:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\DecValTok{1}\NormalTok{, }\StringTok{"ahoj"}\NormalTok{)  }\CommentTok{\# výsledek je vektor tří řetězců}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "TRUE" "1"    "ahoj"
\end{verbatim}

Jednotlivé prvky atomických vektorů mohou mít jména. Jména jsou uložena v~atributu \texttt{names}. Je možné je zadat čtyřmi různými způsoby: přímo ve funkci \texttt{c()}, pomocí funkce \texttt{attr()}, pomocí speciální funkce \texttt{names()} nebo funkce \texttt{setNames()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\AttributeTok{a =} \DecValTok{1}\NormalTok{, }\StringTok{"good parameter"} \OtherTok{=} \DecValTok{7}\NormalTok{, }\AttributeTok{c =} \DecValTok{17}\NormalTok{)}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##              a good parameter              c 
##              1              7             17
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{attr}\NormalTok{(x, }\StringTok{"names"}\NormalTok{) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"A"}\NormalTok{, }\StringTok{"Good Parameter"}\NormalTok{, }\StringTok{"C"}\NormalTok{)}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##              A Good Parameter              C 
##              1              7             17
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{names}\NormalTok{(x) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"aa"}\NormalTok{, }\StringTok{"bb"}\NormalTok{, }\StringTok{"cc"}\NormalTok{)}
\FunctionTok{names}\NormalTok{(x)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "aa" "bb" "cc"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## aa bb cc 
##  1  7 17
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{setNames}\NormalTok{(x, }\FunctionTok{c}\NormalTok{(}\StringTok{"A"}\NormalTok{, }\StringTok{"B"}\NormalTok{, }\StringTok{"C"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  A  B  C 
##  1  7 17
\end{verbatim}

Pokud mají jednotlivé prvky vektorů přiřazená jména, vypisují se na obrazovku nad vlastní hodnoty.

Délku vektoru je možné zjistit pomocí funkce \texttt{length()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{length}\NormalTok{(x)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

Pozor: atomický vektor může mít i~nulovou délku, pokud neobsahuje žádné prvky. (Podobně i~další datové struktury mohou mít nulové rozměry, např.~nulový počet řádků apod.) Prázdný vektor vznikne často tak, že z~existujícího vektoru vyberete hodnoty pomocí podmínky, kterou žádný prvek vektoru nesplní (jak se vybírá část datové struktury uvidíte později):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{9}
\FunctionTok{length}\NormalTok{(x)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 9
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{y }\OtherTok{\textless{}{-}}\NormalTok{ x[x }\SpecialCharTok{\textgreater{}} \DecValTok{10}\NormalTok{]  }\CommentTok{\# vybereme prvky větší než 10, viz dále}
\NormalTok{y}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## integer(0)
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{length}\NormalTok{(y)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 0
\end{verbatim}

Prázdný vektor je možné vytvořit pomocí konstruktorových funkcí \texttt{logical()}, \texttt{integer()}, \texttt{numeric()}, \texttt{character()} apod., které mají jediný parametr, počet prvků. Pokud je zadaný počet prvků nulový, funkce vrátí prázdný vektor. Pokud je počet prvků kladný, vznikne vektor se zadanou délkou. To je užitečné např.~v~situaci, kdy si chcete dopředu připravit vektor určité délky, a~později jej naplnit hodnotami. (Funkce \texttt{numeric()} má poněkud nekonzistentní název, protože vytváří vektor typu \emph{double}.)

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{z }\OtherTok{\textless{}{-}} \FunctionTok{numeric}\NormalTok{(}\DecValTok{0}\NormalTok{)  }\CommentTok{\# parametr je délka vektoru}
\NormalTok{z}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## numeric(0)
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{z }\OtherTok{\textless{}{-}} \FunctionTok{numeric}\NormalTok{(}\DecValTok{10}\NormalTok{)  }\CommentTok{\# vektor 10 hodnot}
\NormalTok{z}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] 0 0 0 0 0 0 0 0 0 0
\end{verbatim}

Některé vektory obsahují předvídatelné sekvence čísel. Pro vytváření takových vektorů existuje operátor dvojtečka~(\texttt{:}) a speciální funkce \texttt{seq()} a \texttt{rep()} a jejich specializované varianty:

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{1}\SpecialCharTok{:}\DecValTok{10}   \CommentTok{\# vektor celých čísel 1 až 10}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1]  1  2  3  4  5  6  7  8  9 10
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{10}\SpecialCharTok{:}\DecValTok{1}   \CommentTok{\# vektor celých čísel sestupně 10 až 1}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] 10  9  8  7  6  5  4  3  2  1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# sekvence od ... do}
\FunctionTok{seq}\NormalTok{(}\AttributeTok{from =} \DecValTok{1}\NormalTok{, }\AttributeTok{to =} \DecValTok{10}\NormalTok{, }\AttributeTok{by =} \DecValTok{3}\NormalTok{)  }\CommentTok{\# s daným krokem}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  4  7 10
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{seq}\NormalTok{(}\AttributeTok{from =} \DecValTok{1}\NormalTok{, }\AttributeTok{to =} \DecValTok{10}\NormalTok{, }\AttributeTok{length.out =} \DecValTok{4}\NormalTok{)  }\CommentTok{\# s danou délkou výsledku}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  4  7 10
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{seq\_along}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{17}\NormalTok{, }\DecValTok{31}\NormalTok{))  }\CommentTok{\# celá čísla od 1 do délky zadaného vektoru}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3 4
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{seq\_len}\NormalTok{(}\DecValTok{7}\NormalTok{)  }\CommentTok{\# celá čísla od 1 nahoru se zadanou nezápornou délkou}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3 4 5 6 7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# opakování hodnot ve vektoru}
\FunctionTok{rep}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{), }\AttributeTok{times =} \DecValTok{5}\NormalTok{)  }\CommentTok{\# celý vektor 5 krát}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] 1 3 1 3 1 3 1 3 1 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{rep\_len}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{), }\AttributeTok{length.out =} \DecValTok{5}\NormalTok{)  }\CommentTok{\# celý vektor do délky 5}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 3 1 3 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{rep}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{), }\AttributeTok{each =} \DecValTok{3}\NormalTok{)  }\CommentTok{\# každý prvek 3 krát}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 1 1 3 3 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{rep}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{6}\NormalTok{, }\AttributeTok{each =} \DecValTok{2}\NormalTok{, }\AttributeTok{times =} \DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] 1 1 2 2 3 3 4 4 5 5 6 6 1 1 2 2 3 3 4 4 5 5 6 6 1 1 2 2 3 3 4 4 5 5 6 6
\end{verbatim}

Složitější varianty použití funkce \texttt{rep()} viz dokumentace.

Pozor! Konstrukce vektorů pomocí operátoru dvojtečka je někdy nebezpečná. Řekněme, že chcete provést nějakou operaci pro každý prvek vektoru~\texttt{x} a že to chcete udělat pomocí cyklu \texttt{for}, viz oddíl~\ref{sec:for}. Při psaní cyklů se často prochází hodnoty pomocného vektoru \texttt{k\ =\ 1:length(x)}. Pokud má vektor~\texttt{x} kladnou délku, je vše v~pořádku. Pokud však vektor~\texttt{x} neobsahuje žádné hodnoty, pak má nulovou délku. Čekali bychom, že pomocný vektor~\texttt{k} bude mít také nulovou délku, takže cyklus neproběhne ani jednou. To však není pravda. Vektor~\texttt{k} je v~tomto případě zkonstruován jako \texttt{1:0}, má tedy hodnotu \texttt{c(1,\ 0)} a délku~2! Taková věc je zdrojem špatně dohledatelných chyb. Je lepší použít \texttt{k\ =\ seq\_along(x)}. Ještě lepší je cyklům se vyhýbat. R~k~tomu má velmi užitečné funkce typu \texttt{map()}, viz kapitola~\ref{kap:iterace-nad-vektory}.

Na obrazovku se vektory vypisují tak, že se jejich jednotlivé hodnoty skládají vedle sebe do řádku. Pokud se všechny hodnoty na řádek nevejdou, začne se vypisovat na dalším řádku. Pokud nejsou jednotlivé prvky vektoru pojmenované, pak je každý řádek uvozen číslem v~hranatých závorkách. To je index prvního prvku vektoru na daném řádku. Protože jsou prvky vektorů číslované přirozenými čísly (tj.~první prvek má index~1), bude první řádek začínat \texttt{{[}1{]}}. Pokud další řádek začíná např.~\texttt{{[}31{]}}, znamená to, že první číslo na daném řádku je 31.~prvek daného vektoru atd.

\begin{Shaded}
\begin{Highlighting}[]
\DecValTok{1}\SpecialCharTok{:}\DecValTok{100}
\end{Highlighting}
\end{Shaded}

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

Pokud jsou prvky vektoru pojmenované, pak R nevypisuje na začátek řádku indexy prvního prvku, ale vypisuje nad jednotlivé prvky jejich jména:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{setNames}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{26}\NormalTok{, letters)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z 
##  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
\end{verbatim}

Poznámka: I~když se vektory vypisují na obrazovku po řádcích, neznamená to že jsou v~R vektory řádkové~-- nejsou ani řádkové, ani sloupcové (jako je to implicitně třeba v~Matlabu). Hodnoty se vypisují po řádcích prostě pro úsporu místa.

R je vektorizovaný jazyk. To znamená, že veškeré aritmetické a logické operace a většina funkcí, která pracuje s~vektory, provádí danou operaci na celých vektorech po prvcích. Pokud např.~vynásobíte dva vektory~\(x\) a \(y\), výsledkem bude vektor, jehož prvky budou násobky odpovídajících prvků obou vektorů, takže \(z_i = x_i \cdot y_i\):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{6}
\NormalTok{y }\OtherTok{\textless{}{-}} \DecValTok{2}\SpecialCharTok{:}\DecValTok{7}
\NormalTok{x }\SpecialCharTok{*}\NormalTok{ y}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  2  6 12 20 30 42
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\SpecialCharTok{\^{}} \DecValTok{2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  4  9 16 25 36
\end{verbatim}

Pozor: pokud se délka vektorů liší, pak R automaticky ``recykluje'' kratší vektor, tj.~opakuje jeho hodnoty znovu a znovu. Při tom vydá R varování jen v~případě, že délka delšího vektoru není celočíselným násobkem délky kratšího vektoru:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{2}
\NormalTok{y }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{6}
\NormalTok{x }\SpecialCharTok{+}\NormalTok{ y}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2 4 4 6 6 8
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\SpecialCharTok{*}\NormalTok{ y}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  4  3  8  5 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{y }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{7}
\NormalTok{x }\SpecialCharTok{+}\NormalTok{ y}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning in x + y: longer object length is not a multiple of shorter object
## length
\end{verbatim}

\begin{verbatim}
## [1] 2 4 4 6 6 8 8
\end{verbatim}

Otestovat, zda je proměnná atomický vektor, není úplně snadné. R~nabízí dvě potřebné funkce, z~nichž však žádná sama o~sobě nestačí. Funkce \texttt{is.atomic()} vrátí hodnotu \texttt{TRUE}, pokud je daná proměnná atomická (tj.~všechny její prvky mají stejný datový typ). Tuto hodnotu však nevrací jen pro atomické vektory, ale i~pro atomické matice, viz oddíl~\ref{sec:datastruc-matrices}. Funkce \texttt{is.vector()} vrací logickou hodnotu \texttt{TRUE}, pokud je proměnná vektor; vektory však v~R nemusejí být nutně atomické; funkce proto vrací \texttt{TRUE} i~pro neatomické vektory (seznamy), viz oddíl~\ref{sec:datastruc-lists}. Zda proměnná obsahuje atomický vektor proto musíme otestovat spojením těchto funkcí:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.atomic}\NormalTok{(x)  }\CommentTok{\# x je atomická, tj.\textbackslash{} homogenní proměnná}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.vector}\NormalTok{(x)  }\CommentTok{\# x je vektor}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.atomic}\NormalTok{(x) }\SpecialCharTok{\&} \FunctionTok{is.vector}\NormalTok{(x)  }\CommentTok{\# x je atomický vektor}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Někdy je potřeba získat z~datové struktury jen vybrané prvky: z~vektoru jednotlivé prvky, z~matice vybrané řádky nebo sloupce apod. K~tomu slouží subsetování. Subsetování lze použít nejen k~získání vybraných prvků z~datové struktury, ale také k~jejich nahrazení nebo doplnění. K~základnímu subsetování slouží hranaté závorky (\texttt{{[}{]}}). V~nich se určí indexy prvků, které je třeba vybrat. Prvky mohou být vybrány třemi způsoby: pomocí svých indexů, pomocí svých jmen a nebo pomocí logických hodnot. Ukážeme si to nejprve na atomických vektorech.

1.~Výběr pomocí číselných indexů. Prvky atomických vektorů jsou číslované přirozenými čísly \(1,\ldots,N\), kde \(N\) je délka vektoru (tj.~první prvek vektoru má index~1, nikoli~0). Při výběru prvků pomocí indexů se vyberou prvky s~danými indexy (pokud jsou indexy kladné), nebo se vynechají prvky s~danými indexy (pokud jsou indexy záporné). Indexování pomocí kladných a záporných čísel nelze míchat. Index~0 se tiše ignoruje.

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# vektor letters obsahuje 26 malých písmen anglické abecedy}
\NormalTok{x }\OtherTok{\textless{}{-}}\NormalTok{ letters[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{]  }\CommentTok{\# prvních dvanáct písmen abecedy}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\DecValTok{1}\NormalTok{]  }\CommentTok{\# první prvek}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "a"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\DecValTok{3}\NormalTok{]  }\CommentTok{\# třetí prvek}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "c"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\FunctionTok{length}\NormalTok{(x)]  }\CommentTok{\# poslední prvek}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "l"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\DecValTok{3}\SpecialCharTok{:}\DecValTok{6}\NormalTok{]  }\CommentTok{\# třetí až šestý prvek včetně}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "c" "d" "e" "f"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\FunctionTok{c}\NormalTok{(}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{7}\NormalTok{)]  }\CommentTok{\# druhý, třetí a sedmý prvek}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "b" "c" "g"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\FunctionTok{c}\NormalTok{(}\SpecialCharTok{{-}}\DecValTok{1}\NormalTok{, }\SpecialCharTok{{-}}\DecValTok{3}\NormalTok{)]  }\CommentTok{\# vynechají se první a třetí prvek}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "b" "d" "e" "f" "g" "h" "i" "j" "k" "l"
\end{verbatim}

2.~Výběr pomocí jmen prvků. Pokud mají prvky vektoru jména, je možné vybírat pomocí vektoru jejich jmen (zde samozřejmě nejde vynechávat pomocí znaménka minus, protože R nemá záporné řetězce):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\AttributeTok{c =} \DecValTok{1}\NormalTok{, }\AttributeTok{b =} \DecValTok{2}\NormalTok{, }\AttributeTok{a =} \DecValTok{3}\NormalTok{)}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## c b a 
## 1 2 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\StringTok{"a"}\NormalTok{]  }\CommentTok{\# prvek s názvem a, tj. zde poslední prvek}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## a 
## 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\FunctionTok{c}\NormalTok{(}\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{)]  }\CommentTok{\# prvky s názvy b a c}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## b c 
## 2 1
\end{verbatim}

3.~Výběr pomocí logických hodnot. R~vybere prvky, které jsou indexovány logickou hodnotou \texttt{TRUE} a vynechá ostatní. Pozor: pokud je logický vektor kratší než subsetovaný vektor, pak se recykluje!

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{12}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{)]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  2  4  5  7  8 10 11
\end{verbatim}

Výběr pomocí logických hodnot je užitečný zejména v~situaci, kdy chceme vybrat prvky, které splňují nějakou podmínku:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[x }\SpecialCharTok{\textgreater{}} \DecValTok{3} \SpecialCharTok{\&}\NormalTok{ x }\SpecialCharTok{\textless{}} \DecValTok{11}\NormalTok{]  }\CommentTok{\# vybere prvky, které jsou větší než tři a menší než 11}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  4  5  6  7  8  9 10
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[x }\SpecialCharTok{\textless{}} \DecValTok{3} \SpecialCharTok{|}\NormalTok{ x }\SpecialCharTok{\textgreater{}} \DecValTok{11}\NormalTok{]  }\CommentTok{\# vybere prvky, které jsou menší než tři nebo větší než 11}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  2 12
\end{verbatim}

Subsetování lze využít k~nahrazení prvků jednoduše tak, že se do výběru uloží nová hodnota, která nahradí starou:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\ConstantTok{NA}\NormalTok{, }\DecValTok{5}\SpecialCharTok{:}\DecValTok{7}\NormalTok{)}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  2  3 NA  5  6  7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\DecValTok{7}\NormalTok{] }\OtherTok{\textless{}{-}} \ConstantTok{Inf}  \CommentTok{\# nahrazení poslední hodnoty nekonečnem}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]   1   2   3  NA   5   6 Inf
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\FunctionTok{is.na}\NormalTok{(x)] }\OtherTok{\textless{}{-}} \DecValTok{0}  \CommentTok{\# nahrazení všech hodnot NA nulou}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]   1   2   3   0   5   6 Inf
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[}\FunctionTok{length}\NormalTok{(x) }\SpecialCharTok{+} \DecValTok{1}\NormalTok{] }\OtherTok{\textless{}{-}} \DecValTok{8}  \CommentTok{\# přidání nové hodnoty za konec vektoru}
\NormalTok{x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]   1   2   3   0   5   6 Inf   8
\end{verbatim}

Pozor: postupné rozšiřování datových struktur vždy o~několik málo prvků je výpočetně velmi neefektivní, protože R musí (téměř) pokaždé alokovat nové místo v~paměti, do něj zkopírovat staré hodnoty a na konec přidat nový prvek. Mnohem efektivnější je naráz alokovat velký blok paměti, do něj postupně uložit hodnoty a blok na konci případně zkrátit:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{numeric}\NormalTok{(}\FloatTok{1e6}\NormalTok{)  }\CommentTok{\# alokace prázdného vektoru o milonu prvků}
\NormalTok{x[}\DecValTok{1}\NormalTok{] }\OtherTok{\textless{}{-}} \DecValTok{1}          \CommentTok{\# přidání prvků (další řádky vynechány)}
\NormalTok{n }\OtherTok{\textless{}{-}} \DecValTok{7654}          \CommentTok{\# skutečný počet vložených prvků}
\NormalTok{x }\OtherTok{\textless{}{-}}\NormalTok{ x[}\DecValTok{1}\SpecialCharTok{:}\NormalTok{n]        }\CommentTok{\# zkrácení vektoru na potřebnou délku}
\end{Highlighting}
\end{Shaded}

Ekvivalentně je vhodné postupovat v~případě všech homogenních datových struktur.

Pozor: \texttt{numeric()} vytvoří vektor samých nul. Možná je lepší použít \texttt{rep(NA\_real\_,\ 1e6)}, které vytvoří reálný vektor hodnot \texttt{NA}. Většina lidí však používá funkce \texttt{numeric()}, \texttt{character()} apod.

V~R je možné výběry ze všech datových struktur řetězit~-- následující výběr vybírá z~výsledku předchozího výběru:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{10}
\NormalTok{v[}\DecValTok{6}\SpecialCharTok{:}\DecValTok{10}\NormalTok{]     }\CommentTok{\# 6. až 10. prvek v}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  6  7  8  9 10
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v[}\DecValTok{6}\SpecialCharTok{:}\DecValTok{10}\NormalTok{][}\DecValTok{2}\NormalTok{]  }\CommentTok{\# druhý prvek z výběru 6. až 10. prvku v}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 7
\end{verbatim}

Do zřetězeného výběru je obvykle možné dosazovat hodnoty:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v[}\DecValTok{6}\SpecialCharTok{:}\DecValTok{10}\NormalTok{][}\DecValTok{2}\NormalTok{] }\OtherTok{\textless{}{-}} \ConstantTok{NA}
\NormalTok{v}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1]  1  2  3  4  5  6 NA  8  9 10
\end{verbatim}

\hypertarget{sec:datastruc-matrices}{%
\section{Atomické matice}\label{sec:datastruc-matrices}}

Atomická matice je matice (tj.~dvourozměrná tabulka), jejíž všechny prvky mají stejný datový typ (např.~celé číslo). Pro datovou analýzu nejsou matice příliš důležité, někdy se však hodí pro rychlou maticovou algebru a také některé funkce vracejí nebo očekávají jako vstup matice.

Nejjednodušší způsob, jak vytvořit atomickou matici je pomocí funkce \texttt{matrix()}. Prvním parametrem je vektor, který obsahuje data. Další parametry určují počet řádků a počet sloupců matice, způsob, jak budou data do matice skládaná (zda podle řádků či sloupců; implicitně se data do matic skládají po sloupcích) a pojmenování dimenzí matice. Není potřeba zadávat všechny parametry, pokud R dokáže odhadnout hodnotu jednoho parametru z~hodnot ostatních parametrů. R~např.~umí z~délky zadaného vektoru a zadaného počtu řádků odhadnout počet sloupců.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)  }\CommentTok{\# matice se třemi řádky a čtyřmi sloupci, po sloupcích}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{, }\AttributeTok{ncol =} \DecValTok{4}\NormalTok{, }\AttributeTok{byrow =} \ConstantTok{TRUE}\NormalTok{)  }\CommentTok{\# stejný rozměr, data po řádcích}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12
\end{verbatim}

Při tvorbě matic R recykluje data. To znamená, že pokud je zadaných hodnot méně, než vyžadují rozměry matice, R začne číst datový vektor znovu od začátku. To může být zdrojem nepříjemných chyb. Naštěstí R vypíše varování, ovšem pouze v~případě, že počet prvků matice není celočíselným násobkem délky zadaného vektoru.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{9}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{, }\AttributeTok{ncol =} \DecValTok{4}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning in matrix(1:9, nrow = 3, ncol = 4): data length [9] is not a sub-
## multiple or multiple of the number of columns [4]
\end{verbatim}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7    1
## [2,]    2    5    8    2
## [3,]    3    6    9    3
\end{verbatim}

Otestovat, zda je objekt matice, je možné pomocí funkce \texttt{is.matrix()}; převést data na matici je možné pomocí konverzní funkce \texttt{as.matrix()}.

Zjistit rozměry matice je možné pomocí následujících funkcí: \texttt{nrow()} vrátí počet řádků matice, \texttt{ncol()} vrátí počet sloupců matice, \texttt{dim()} vrací vektor s~počtem řádků a sloupců matice a \texttt{length()} vrací počet prvků matice. (Pro vektory vrací funkce \texttt{nrow()}, \texttt{ncol()} a \texttt{dim()} hodnotu \texttt{NULL}.)

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{m }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)}
\NormalTok{m}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{nrow}\NormalTok{(m)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{ncol}\NormalTok{(m)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{dim}\NormalTok{(m)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3 4
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{length}\NormalTok{(m)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 12
\end{verbatim}

Matice a podobné objekty je možné skládat pomocí funkcí \texttt{rbind()} a \texttt{cbind()}. První (\texttt{rbind()} od ``row bind'') spojuje matice po řádcích (tj.~skládá je pod sebe), druhá (\texttt{cbind()} od ``column bind'') po sloupcích (tj.~skládá je vedle sebe):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{A }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)}
\NormalTok{B }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\DecValTok{101}\SpecialCharTok{:}\DecValTok{112}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)}
\FunctionTok{rbind}\NormalTok{(A, B)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
## [4,]  101  104  107  110
## [5,]  102  105  108  111
## [6,]  103  106  109  112
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{cbind}\NormalTok{(A, B)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
## [1,]    1    4    7   10  101  104  107  110
## [2,]    2    5    8   11  102  105  108  111
## [3,]    3    6    9   12  103  106  109  112
\end{verbatim}

Matice mohou mít následující atributy: \texttt{dim} je celočíselný vektor rozměrů (viz výše), jména řádků (čte i~nastavuje se funkcí \texttt{rownames()}), jména sloupců (čte i~nastavuje se funkcí \texttt{colnames()}) a jména dimenzí včetně jmen řádků a sloupců (čte i~nastavuje se funkcí \texttt{dimnames()}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{rownames}\NormalTok{(A) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{)}
\FunctionTok{colnames}\NormalTok{(A) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"alpha"}\NormalTok{, }\StringTok{"beta"}\NormalTok{, }\StringTok{"gamma"}\NormalTok{, }\StringTok{"delta"}\NormalTok{)}
\NormalTok{A}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   alpha beta gamma delta
## a     1    4     7    10
## b     2    5     8    11
## c     3    6     9    12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{dimnames}\NormalTok{(A) }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\AttributeTok{id =} \FunctionTok{c}\NormalTok{(}\StringTok{"A"}\NormalTok{, }\StringTok{"B"}\NormalTok{, }\StringTok{"C"}\NormalTok{), }\AttributeTok{variables =} \FunctionTok{c}\NormalTok{(}\StringTok{"Alpha"}\NormalTok{, }\StringTok{"Beta"}\NormalTok{, }\StringTok{"Gamma"}\NormalTok{, }\StringTok{"Delta"}\NormalTok{))}
\NormalTok{A}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##    variables
## id  Alpha Beta Gamma Delta
##   A     1    4     7    10
##   B     2    5     8    11
##   C     3    6     9    12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{attributes}\NormalTok{(A)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $dim
## [1] 3 4
## 
## $dimnames
## $dimnames$id
## [1] "A" "B" "C"
## 
## $dimnames$variables
## [1] "Alpha" "Beta"  "Gamma" "Delta"
\end{verbatim}

Atomická matice je implementována jako atomický vektor, který má přiřazený atribut \texttt{dim}, který je celočíselný vektor délky dva:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{12}
\NormalTok{M}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{dim}\NormalTok{(M) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{)}
\NormalTok{M}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.matrix}\NormalTok{(M)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Podobně lze zrušením atributu \texttt{dim} převést matici zpět na vektor (matice se vektorizuje po sloupcích). Stejného výsledku jde dosáhnout pomocí funkce \texttt{as.vector()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.vector}\NormalTok{(M)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{dim}\NormalTok{(M) }\OtherTok{\textless{}{-}} \ConstantTok{NULL}
\NormalTok{M}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12
\end{verbatim}

Protože matice je atomický vektor, který má přiřazený atribut \texttt{dim}, funkce \texttt{is.atomic()} vrací pro matici hodnotu \texttt{TRUE}; funkce \texttt{is.vector()} však samozřejmě vrací \texttt{FALSE}, protože testuje, zda je v~proměnné uložen vektor.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)}
\FunctionTok{is.atomic}\NormalTok{(M)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.vector}\NormalTok{(M)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

\hypertarget{maticovuxe1-aritmetika}{%
\subsection{Maticová aritmetika}\label{maticovuxe1-aritmetika}}

Obyčejné symboly násobení (\texttt{*}), dělení (\texttt{/}) a umocňování (\texttt{\^{}}) pracují ``po prvcích''. Při násobení se např.~vynásobí odpovídající prvky matice. Matice tedy musejí mít stejné rozměry (stejný počet řádků a sloupců).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{A }\SpecialCharTok{*}\NormalTok{ B}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##    variables
## id  Alpha Beta Gamma Delta
##   A   101  416   749  1100
##   B   204  525   864  1221
##   C   309  636   981  1344
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{A }\SpecialCharTok{\^{}} \DecValTok{2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##    variables
## id  Alpha Beta Gamma Delta
##   A     1   16    49   100
##   B     4   25    64   121
##   C     9   36    81   144
\end{verbatim}

Pro skutečné maticové násobení se používá operátor \texttt{\%*\%}. Inverzní matici vrací funkce \texttt{solve()} (obecně tato funkce řeší soustavy lineárních rovnic). K~transponování matice slouží funkce \texttt{t()}. Hlavní diagonálu matice vrací funkce \texttt{diag()}.

Speciální matice:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{diag}\NormalTok{(}\DecValTok{1}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{, }\AttributeTok{ncol =} \DecValTok{3}\NormalTok{)  }\CommentTok{\# jednotková matice}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    1    0
## [3,]    0    0    1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{matrix}\NormalTok{(}\DecValTok{0}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{, }\AttributeTok{ncol =} \DecValTok{3}\NormalTok{)  }\CommentTok{\# nulová matice (využívá recyklace)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3]
## [1,]    0    0    0
## [2,]    0    0    0
## [3,]    0    0    0
\end{verbatim}

Příklad inverze:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{8}\NormalTok{, }\DecValTok{0}\NormalTok{), }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)}
\NormalTok{invM }\OtherTok{\textless{}{-}} \FunctionTok{solve}\NormalTok{(M)}
\NormalTok{E }\OtherTok{\textless{}{-}} \FunctionTok{diag}\NormalTok{(}\DecValTok{1}\NormalTok{, }\AttributeTok{nrow =} \FunctionTok{nrow}\NormalTok{(M), }\AttributeTok{ncol =} \FunctionTok{ncol}\NormalTok{(M))}
\FunctionTok{all.equal}\NormalTok{(M }\SpecialCharTok{\%*\%}\NormalTok{ invM, E)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{all.equal}\NormalTok{(invM }\SpecialCharTok{\%*\%}\NormalTok{ M, E)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\hypertarget{subsetovuxe1nuxed-matic}{%
\subsection{Subsetování matic}\label{subsetovuxe1nuxed-matic}}

Subsetování matic je podobné jako u~atomických vektorů s~jedním rozdílem: protože má matice řádky a sloupce, je třeba subsetovat pomocí dvou indexů. První index vybírá řádky, druhý sloupce:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)}
\NormalTok{M}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{]  }\CommentTok{\# prvek ve druhém řádku a třetím sloupci}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 8
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, }\FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{4}\NormalTok{)]  }\CommentTok{\# prvky na prvních dvou řádcích a v prvním a čtvrtém sloupci}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2]
## [1,]    1   10
## [2,]    2   11
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[}\SpecialCharTok{{-}}\DecValTok{1}\NormalTok{, }\SpecialCharTok{{-}}\DecValTok{1}\NormalTok{]  }\CommentTok{\# matice bez prvního řádku a sloupce}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3]
## [1,]    5    8   11
## [2,]    6    9   12
\end{verbatim}

Pokud je jeden z~indexů prázdný, vybírá celý řádek nebo sloupec:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, ]  }\CommentTok{\# celé první dva řádky}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[, }\FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{)]  }\CommentTok{\# první a třetí sloupec}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2]
## [1,]    1    7
## [2,]    2    8
## [3,]    3    9
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[M[, }\DecValTok{1}\NormalTok{] }\SpecialCharTok{\textgreater{}=} \DecValTok{2}\NormalTok{, ]  }\CommentTok{\# všechny řádky, ve kterých je prvek v prvním sloupci \textgreater{}= 2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    2    5    8   11
## [2,]    3    6    9   12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[M[, }\DecValTok{1}\NormalTok{] }\SpecialCharTok{\textgreater{}=} \DecValTok{2}\NormalTok{, M[}\DecValTok{1}\NormalTok{, ] }\SpecialCharTok{\textless{}} \DecValTok{6}\NormalTok{]  }\CommentTok{\# submatice}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2]
## [1,]    2    5
## [2,]    3    6
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[ , ]  }\CommentTok{\# celá matice M}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
\end{verbatim}

Pokud se matice indexuje jen jedním indexem, R~ji tiše převede na jeden vektor (spojí sloupce matice za sebe) a vybere prvky z~takto vzniklého vektoru:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[}\DecValTok{4}\NormalTok{]  }\CommentTok{\# vrací 1. prvek ve 2. sloupci, protože je to 4. prvek vektoru}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[}\FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{4}\SpecialCharTok{:}\DecValTok{7}\NormalTok{)]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 4 5 6 7
\end{verbatim}

Subsetování může nejen vybírat hodnoty, ale také měnit jejich pořadí. Zadáním indexů můžeme např.~otočit pořadí sloupců matice:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\DecValTok{8}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{7}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{11}\NormalTok{, }\DecValTok{6}\NormalTok{, }\DecValTok{12}\NormalTok{, }\DecValTok{1}\NormalTok{, }\DecValTok{4}\NormalTok{, }\DecValTok{9}\NormalTok{, }\DecValTok{10}\NormalTok{), }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)}
\NormalTok{M}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    8    2    6    4
## [2,]    5    3   12    9
## [3,]    7   11    1   10
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[, }\DecValTok{4}\SpecialCharTok{:}\DecValTok{1}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    4    6    2    8
## [2,]    9   12    3    5
## [3,]   10    1   11    7
\end{verbatim}

Stejným způsobem můžeme dosáhnout i~zajímavějších efektů: např.~seřadit řádky nebo sloupce podle hodnot vybraného vektoru nebo je náhodně permutovat. Funkce \texttt{order()} vrací indexy uspořádané podle velikosti původního vektoru. Funkce např.~umožňuje setřídit hodnoty všech sloupců matice podle jednoho sloupce:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# indexy prvků 1. sloupce matice M seřazené podle velikosti prvků,}
\CommentTok{\# tj. na 1. místě je 2. prvek původního vektoru (5), pak 3. prvek (7) atd.}
\FunctionTok{order}\NormalTok{(M[, }\DecValTok{1}\NormalTok{]) }
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2 3 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[}\FunctionTok{order}\NormalTok{(M[, }\DecValTok{1}\NormalTok{]), ]  }\CommentTok{\# řádky matice seřazené podle prvního sloupce}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    5    3   12    9
## [2,]    7   11    1   10
## [3,]    8    2    6    4
\end{verbatim}

Funkce \texttt{sample()} náhodně permutuje zadaná čísla. Lze jí tak mimo jiné využít k~náhodné permutaci sloupců matice:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{o }\OtherTok{\textless{}{-}} \FunctionTok{sample}\NormalTok{(}\FunctionTok{ncol}\NormalTok{(M))  }\CommentTok{\# čísla 1:ncol(M) v náhodném pořadí}
\NormalTok{o}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3 1 4 2
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[, o]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1] [,2] [,3] [,4]
## [1,]    6    8    4    2
## [2,]   12    5    9    3
## [3,]    1    7   10   11
\end{verbatim}

Subsetování se vždy snaží snížit rozměry matice~-- pokud počet řádků nebo sloupců klesne na~1, matice se změní ve vektor. Pokud tomu chceme zabránit, je třeba přidat parametr \texttt{drop\ =\ FALSE}. (Nemělo by vám být divné, že je možné hranatým závorkám přidávat parametry~-- jako vše v~R je i~použití hranatých závorek volání funkce~-- a~funkce mohou mít parametry.)

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[, }\DecValTok{1}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 8 5 7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M[, }\DecValTok{1}\NormalTok{, drop }\OtherTok{=} \ConstantTok{FALSE}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1]
## [1,]    8
## [2,]    5
## [3,]    7
\end{verbatim}

\hypertarget{sec:datastruc-lists}{%
\section{Neatomické vektory (seznamy)}\label{sec:datastruc-lists}}

Neatomické vektory (častěji nazývané seznamy) jsou vektory, jejichž jednotlivé prvky mohou mít různé datové typy, třeba i~jiné seznamy. Seznamy jsou někdy užitečné, protože umožňují v~jedné proměnné skladovat různé typy dat. Jejich hlavní význam však spočívá v~tom, že se používají jako základ pro tvorbu většiny objektů v~systému \texttt{S3}, viz~kapitola~\ref{kap:objekty}.

Seznamy se vytvářejí pomocí funkce \texttt{list()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(1L, }\DecValTok{11}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\StringTok{"ahoj"}\NormalTok{, }\FunctionTok{list}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\StringTok{"ahoj"}\NormalTok{))}
\NormalTok{l}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] 1
## 
## [[2]]
## [1] 11
## 
## [[3]]
## [1] 1 2 3
## 
## [[4]]
## [1] "ahoj"
## 
## [[5]]
## [[5]][[1]]
## [1] 1
## 
## [[5]][[2]]
## [1] 1 2 3
## 
## [[5]][[3]]
## [1] "ahoj"
\end{verbatim}

Stejně jako atomické vektory, i~seznamy mohou mít atribut \texttt{names}, tj.~jednotlivé prvky seznamu mohou mít svá jména. Ta se přiřazují stejně jako v~případě atomických vektorů:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\AttributeTok{a =} \DecValTok{1}\NormalTok{, }\AttributeTok{b =} \StringTok{"ahoj"}\NormalTok{, }\AttributeTok{c =} \DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\AttributeTok{d =} \FunctionTok{list}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\StringTok{"ahoj"}\NormalTok{))}
\FunctionTok{names}\NormalTok{(l)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "a" "b" "c" "d"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $a
## [1] 1
## 
## $b
## [1] "ahoj"
## 
## $c
## [1] 1 2 3
## 
## $d
## $d[[1]]
## [1] 1 2 3
## 
## $d[[2]]
## [1] "ahoj"
\end{verbatim}

Délku seznamu zjistíme pomocí funkce \texttt{length()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{length}\NormalTok{(l)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4
\end{verbatim}

K~otestování, zda je proměnná seznam, slouží funkce \texttt{is.list()}. Funkce \texttt{is.vector()} vrací hodnotu \texttt{TRUE} jak pro atomické vektory, tak i~pro seznamy.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.list}\NormalTok{(l)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.vector}\NormalTok{(l)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Strukturu seznamu je možné přehledně zobrazit pomocí funkce \texttt{str()}. Podobný výsledek dostanete v~RStudiu tak, že v~záložce \texttt{Environment} kliknete na trojúhelníček v~kolečku vedle jména seznamu. Musíte však být v~módu List.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str}\NormalTok{(l)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 4
##  $ a: num 1
##  $ b: chr "ahoj"
##  $ c: int [1:3] 1 2 3
##  $ d:List of 2
##   ..$ : int [1:3] 1 2 3
##   ..$ : chr "ahoj"
\end{verbatim}

Subsetování seznamů je poněkud složitější, než je tomu u~atomických proměnných. Subsetování pomocí hranatých závorek zachovává mód proměnné. To znamená, že použití hranatých závorek na seznam vrací opět seznam. Pokud chceme získat přímo prvek uložený v seznamu, musíme použít dvojité hranaté závorky (\texttt{{[}{[}{]}{]}}). Podobnou funkci plní i~operátor dolar (\texttt{\$}).

Subsetování seznamu pomocí hranatých závorek vrací prvky opět zabalené do seznamu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\AttributeTok{a =} \DecValTok{1}\NormalTok{, }\AttributeTok{b =} \DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\AttributeTok{c =} \StringTok{"ahoj"}\NormalTok{)}
\NormalTok{l}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $a
## [1] 1
## 
## $b
## [1] 1 2 3
## 
## $c
## [1] "ahoj"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[}\DecValTok{1}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $a
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.list}\NormalTok{(l[}\DecValTok{1}\NormalTok{])}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $a
## [1] 1
## 
## $b
## [1] 1 2 3
\end{verbatim}

Pokud chceme získat vlastní prvek seznamu, musíme použít dvojité hranaté závorky. Dvojité hranaté závorky ``vybalí'' daný prvek ze seznamu ven:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[[}\DecValTok{2}\NormalTok{]]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.list}\NormalTok{(l[[}\DecValTok{2}\NormalTok{]])}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.numeric}\NormalTok{(l[[}\DecValTok{2}\NormalTok{]])}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Syntaxe dvojitých hranatých závorek je poněkud nečekaná. Pokud je argumentem vektor, nevrací dvojité hranaté závorky vektor hodnot (to ani nejde, protože výsledkem by musel být opět seznam), nýbrž se vektor přeloží na rekurentní volání dvojitých hranatých závorek:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[[}\DecValTok{2}\NormalTok{]][[}\DecValTok{3}\NormalTok{]]  }\CommentTok{\# třetí prvek vektoru, který je druhým prvkem seznamu}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[[}\DecValTok{2}\SpecialCharTok{:}\DecValTok{3}\NormalTok{]]     }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# protože druhým prvkem seznamu je zde atomický vektor, mohou být druhé závorky jednoduché:}
\NormalTok{l[[}\DecValTok{2}\NormalTok{]][}\DecValTok{3}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

Pokud jsou prvky seznamu pojmenované, nabízí R zkratku ke dvojitým hranatým závorkám: operátor dolar (\texttt{\$}): \texttt{l{[}{[}"b"{]}{]}} je totéž jako \texttt{l\$b}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[[}\StringTok{"b"}\NormalTok{]]  }\CommentTok{\# prvek se jménem b}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l}\SpecialCharTok{$}\NormalTok{b       }\CommentTok{\# totéž (uvozovky se zde neuvádějí)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3
\end{verbatim}

Použití dolaru od dvojitých závorek v~jednom ohledu liší: pokud máme jméno prvku, který chceme získat uloženo v~proměnné, je třeba použít hranaté závorky~-- operátor dolar zde nelze použít:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{element }\OtherTok{\textless{}{-}} \StringTok{"c"}
\CommentTok{\# element není v uvozovkách, protože vybíráme hodnotu, která je v něm uložená:}
\NormalTok{l[[element]]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "ahoj"
\end{verbatim}

Pokud indexujeme jménem prvek seznamu, který v~seznamu chybí, dostaneme hodnotu \texttt{NULL}. Pokud jej však indexujeme číselným indexem, dostaneme chybu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[[}\StringTok{"d"}\NormalTok{]]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## NULL
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l}\SpecialCharTok{$}\NormalTok{d}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## NULL
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[[}\DecValTok{4}\NormalTok{]]  }\CommentTok{\# chybný řádek}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error in l[[4]]: subscript out of bounds
\end{verbatim}

Seznamy umožňují používat i~jen části jmen prvků, pokud jsou určeny jednoznačně (tomu se říká ``partial matching''). S~dolarem partial matching zapnutý vždy; s~dvojitými hranatými závorkami jen v~případě, že o~to požádáte parametrem \texttt{exact\ =\ FALSE}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\AttributeTok{prvni\_prvek =} \DecValTok{1}\NormalTok{, }\AttributeTok{druhy\_prevk =} \DecValTok{2}\NormalTok{)}
\NormalTok{l}\SpecialCharTok{$}\NormalTok{p}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[[}\StringTok{"p"}\NormalTok{]]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## NULL
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{l[[}\StringTok{"p"}\NormalTok{, exact }\OtherTok{=} \ConstantTok{FALSE}\NormalTok{]]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

Doporučuji partial matching nikdy nevyužívat~-- může být zdrojem špatně dohledatelných chyb!

\hypertarget{tabulky-tux159uxeddy-data.frame}{%
\section{\texorpdfstring{Tabulky třídy \emph{data.frame}}{Tabulky třídy data.frame}}\label{tabulky-tux159uxeddy-data.frame}}

Pro analýzu dat jsou nejdůležitější datovou strukturou tabulky. Každý sloupec tabulky může obsahovat proměnné jiného typu, v~rámci sloupce však musí být typ stejný. Tím se tabulky liší od atomických matic, které musí mít všechny prvky stejného typu. Obvyklé použití tabulek je takové, že řádky tabulky představují jednotlivá pozorování a sloupce jednotlivé proměnné.

R~má několik implementací tabulek. Základní třída tabulek, které se budeme věnovat v~tomto oddíle, se nazývá \emph{data.frame}. Technicky je implementovaná jako seznamy atomických vektorů o~stejné délce, které jsou spojené vedle sebe. V~příštím oddíle se podíváme na poněkud příjemnější variantu tabulek třídy \emph{tibble}.

Tabulky třídy \emph{data.frame} se tvoří pomocí funkce \texttt{data.frame()}. Řekněme, že chceme zaznamenat údaje o~subjektech, které se zúčastnily nějakého experimentu. Pro každý subjekt pozorujeme jeho identifikační číslo id, výšku a váhu. Pokud máme čtyři subjekty, můžeme vytvořit tabulku např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{experiment }\OtherTok{\textless{}{-}} \FunctionTok{data.frame}\NormalTok{(}\AttributeTok{id =} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{41}\NormalTok{),}
                         \AttributeTok{vyska =} \FunctionTok{c}\NormalTok{(}\DecValTok{158}\NormalTok{, }\DecValTok{174}\NormalTok{, }\DecValTok{167}\NormalTok{, }\DecValTok{203}\NormalTok{),}
                         \AttributeTok{vaha =} \FunctionTok{c}\NormalTok{(}\DecValTok{51}\NormalTok{, }\DecValTok{110}\NormalTok{, }\DecValTok{68}\NormalTok{, }\DecValTok{97}\NormalTok{))}
\NormalTok{experiment}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   id vyska vaha
## 1  1   158   51
## 2  2   174  110
## 3  3   167   68
## 4 41   203   97
\end{verbatim}

Při zadávání vektorů do tabulek můžeme zadat jejich jména, která pak R vypíše. R~samo přidá jména řádků (automaticky jim dá přirozená čísla od 1 do počtu proměnných).

I~při konstrukci tabulek R recykluje proměnné, pokud není zadáno dost hodnot. Pokud jsou všechny naše subjekty muži, stačí zadat tuto hodnotu jen jednou~-- R~ji zrecykluje.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{experiment }\OtherTok{\textless{}{-}} \FunctionTok{data.frame}\NormalTok{(}\AttributeTok{id =} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{41}\NormalTok{),}
                         \AttributeTok{gender =} \StringTok{"muž"}\NormalTok{,}
                         \AttributeTok{vyska =} \FunctionTok{c}\NormalTok{(}\DecValTok{158}\NormalTok{, }\DecValTok{174}\NormalTok{, }\DecValTok{167}\NormalTok{, }\DecValTok{203}\NormalTok{),}
                         \AttributeTok{vaha =} \FunctionTok{c}\NormalTok{(}\DecValTok{51}\NormalTok{, }\DecValTok{110}\NormalTok{, }\DecValTok{68}\NormalTok{, }\DecValTok{97}\NormalTok{),}
                         \AttributeTok{zdravy =} \FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{))}
\NormalTok{experiment}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   id gender vyska vaha zdravy
## 1  1    muž   158   51   TRUE
## 2  2    muž   174  110   TRUE
## 3  3    muž   167   68  FALSE
## 4 41    muž   203   97   TRUE
\end{verbatim}

Poznámka: Starší verze~R při zadání dat do tabulek pomocí funkce \texttt{data.frame()} automaticky převedly všechny řetězce na faktory, viz~oddíl~\ref{sec:factors}. Této konverzi šlo zabránit nastavením parametru \texttt{stringsAsFactors\ =\ FALSE}. Od verze R~4.0 má parametr \texttt{stringsAsFactors} hodnotu \texttt{FALSE} implicitně. Pokud tedy chceme v~novějším~R převést řetězce na faktory, musíme nastavit parametr \texttt{stringsAsFactors} na hodnotu \texttt{TRUE} nebo je převést pomocí funkce \texttt{factor()}, což je zřejmě rozumnější, viz~oddíl~\ref{sec:factors}.

Někdy se hodí vytvořit tabulku, která obsahuje všechny možné kombinace hodnot nějakého vektoru. K~tomu slouží funkce \texttt{expand.grid()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{expand.grid}\NormalTok{(}\AttributeTok{x =} \DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\AttributeTok{y =} \FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"male"}\NormalTok{, }\StringTok{"female"}\NormalTok{)), }\AttributeTok{z =} \FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{FALSE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##    x      y     z
## 1  1   male  TRUE
## 2  2   male  TRUE
## 3  3   male  TRUE
## 4  1 female  TRUE
## 5  2 female  TRUE
## 6  3 female  TRUE
## 7  1   male FALSE
## 8  2   male FALSE
## 9  3   male FALSE
## 10 1 female FALSE
## 11 2 female FALSE
## 12 3 female FALSE
\end{verbatim}

Počet řádků tabulky zjistíme pomocí funkce \texttt{nrow()}, počet sloupců funkcí \texttt{ncol()} nebo \texttt{length()}; funguje i~funkce \texttt{dim()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{nrow}\NormalTok{(experiment)    }\CommentTok{\# počet řádků}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{ncol}\NormalTok{(experiment)    }\CommentTok{\# počet sloupců}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 5
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{length}\NormalTok{(experiment)  }\CommentTok{\# počet sloupců}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 5
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{dim}\NormalTok{(experiment)     }\CommentTok{\# vektor počtu řádků a sloupců}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4 5
\end{verbatim}

Tabulky mají standardně tři atributy: \texttt{class} (jméno třídy~-- data set je totiž objekt), \texttt{names} obsahuje jména sloupců (tj.~jednotlivých proměnných) a \texttt{row.names} obsahuje jména jednotlivých řádků (tj.~pozorování, implicitně mají hodnoty 1, 2 atd.).

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{attributes}\NormalTok{(experiment)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $names
## [1] "id"     "gender" "vyska"  "vaha"   "zdravy"
## 
## $class
## [1] "data.frame"
## 
## $row.names
## [1] 1 2 3 4
\end{verbatim}

Jména řádků můžete zjistit i změnit pomocí funkcí \texttt{rownames()} a \texttt{row.names()}, jména sloupců pomocí funkcí \texttt{colnames()} nebo \texttt{names()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{colnames}\NormalTok{(experiment) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"id"}\NormalTok{, }\StringTok{"sex"}\NormalTok{, }\StringTok{"height"}\NormalTok{, }\StringTok{"weight"}\NormalTok{, }\StringTok{"healthy"}\NormalTok{)}
\NormalTok{experiment}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   id sex height weight healthy
## 1  1 muž    158     51    TRUE
## 2  2 muž    174    110    TRUE
## 3  3 muž    167     68   FALSE
## 4 41 muž    203     97    TRUE
\end{verbatim}

Jména řádků vypadají na první pohled jako dobrý způsob, jak uložit nějakou identifikaci pozorování, např.~id subjektu v~experimentu. Nedělejte to! Veškeré informace o~pozorování ukládejte přímo do tabulky. Je to filosoficky správnější a i~praktičtější: některé funkce, které se používají ke zpracování tabulek, jména řádků odstraní. Stejně tak některé formáty, do kterých se data ukládají, jména řádků nepodporují, takže byste přišli o~důležité informace. Naproti tomu jména sloupců (tj.~proměnných) jsou bezpečná.

Pozor: R vám dovolí změnit i~třídu objektu tím, že přepíšete atribut \texttt{class} (buď pomocí funkce \texttt{attr()} nebo funkce \texttt{class()}). Pak se však budou pro daný objekt volat jiné funkce (metody) a výsledek může být podivný. Nedělejte to, pokud nevíte, co děláte.

Někdy je užitečné moci převést tabulku na matici a matici na tabulku. K~převodu tabulky na matici slouží funkce \texttt{as.matrix()} a \texttt{data.matrix()}. První převede všechny sloupce tabulky automatickou konverzí na stejný typ, a~pak na matici. Druhá převede logické hodnoty a faktory na celá čísla, řetězce na faktory a ty na celá čísla. Pokud jsou po této konverzi všechny sloupce typu \emph{integer}, má výsledná matice tento typ, jinak má typ \emph{double}. Při automatické konverzi můžeme skončit s~řetězci, což nemusí být žádoucí; s~explicitní konverzí na reálná čísla můžeme řetězce ztratit a faktory mohou být zavádějící (faktory se převedou na čísla jako při konverzi na celé číslo).

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.matrix}\NormalTok{(experiment)    }\CommentTok{\# použije automatickou konverzi na stejný typ}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      id   sex   height weight healthy
## [1,] " 1" "muž" "158"  " 51"  "TRUE" 
## [2,] " 2" "muž" "174"  "110"  "TRUE" 
## [3,] " 3" "muž" "167"  " 68"  "FALSE"
## [4,] "41" "muž" "203"  " 97"  "TRUE"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{data.matrix}\NormalTok{(experiment)  }\CommentTok{\# použije explicitní konverzi na reálná čísla}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      id sex height weight healthy
## [1,]  1   1    158     51       1
## [2,]  2   1    174    110       1
## [3,]  3   1    167     68       0
## [4,] 41   1    203     97       1
\end{verbatim}

Matici lze převést na tabulku pomocí funkcí \texttt{as.data.frame()} i \texttt{data.frame()}. Pokud má matice pojmenované sloupce, jejich jména jsou v~tabulce zachována; v~opačném případě je R samo pojmenuje \texttt{V1}, \texttt{V2} atd nebo \texttt{X1}, \texttt{X2} atd.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{M }\OtherTok{\textless{}{-}} \FunctionTok{matrix}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{, }\AttributeTok{nrow =} \DecValTok{3}\NormalTok{)}
\FunctionTok{as.data.frame}\NormalTok{(M)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   V1 V2 V3 V4
## 1  1  4  7 10
## 2  2  5  8 11
## 3  3  6  9 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{data.frame}\NormalTok{(M)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   X1 X2 X3 X4
## 1  1  4  7 10
## 2  2  5  8 11
## 3  3  6  9 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{colnames}\NormalTok{(M) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{, }\StringTok{"d"}\NormalTok{)}
\FunctionTok{as.data.frame}\NormalTok{(M)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   a b c  d
## 1 1 4 7 10
## 2 2 5 8 11
## 3 3 6 9 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{data.frame}\NormalTok{(M)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   a b c  d
## 1 1 4 7 10
## 2 2 5 8 11
## 3 3 6 9 12
\end{verbatim}

\hypertarget{subsetovuxe1nuxed-tabulek-tux159uxeddy-data.frame}{%
\subsection{\texorpdfstring{Subsetování tabulek třídy \emph{data.frame}}{Subsetování tabulek třídy data.frame}}\label{subsetovuxe1nuxed-tabulek-tux159uxeddy-data.frame}}

Tabulky jsou ``kříženec'' mezi seznamy a maticemi, takže je na ně možné je subsetovat jako matice i~jako seznamy. Pokud použijete jeden index, pak je indexujete jako seznamy, pokud dva indexy, pak je indexujete jako matice. V~prvním případě tedy \texttt{{[}} vrátí tabulku, ve druhém může vrátit tabulku (pokud se vybere více sloupců), nebo vektor (pokud se vybere jen jeden sloupec). Dolar i~dvojité hranaté závorky vrací jeden sloupec, tj.~vektor:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d }\OtherTok{\textless{}{-}} \FunctionTok{data.frame}\NormalTok{(}\AttributeTok{x =} \DecValTok{1}\SpecialCharTok{:}\DecValTok{7}\NormalTok{,}
                \AttributeTok{y =} \FunctionTok{c}\NormalTok{(}\DecValTok{3}\NormalTok{, }\DecValTok{1}\NormalTok{, }\ConstantTok{NA}\NormalTok{, }\DecValTok{7}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{12}\NormalTok{, }\ConstantTok{NA}\NormalTok{))}
\NormalTok{d}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x  y
## 1 1  3
## 2 2  1
## 3 3 NA
## 4 4  7
## 5 5  5
## 6 6 12
## 7 7 NA
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d}\SpecialCharTok{$}\NormalTok{x      }\CommentTok{\# vektor x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3 4 5 6 7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[[}\StringTok{"x"}\NormalTok{]] }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3 4 5 6 7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[[}\DecValTok{1}\NormalTok{]]   }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3 4 5 6 7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\StringTok{"x"}\NormalTok{]   }\CommentTok{\# tabulka s jediným sloupcem}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x
## 1 1
## 2 2
## 3 3
## 4 4
## 5 5
## 6 6
## 7 7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\DecValTok{1}\NormalTok{]     }\CommentTok{\# opět tabulka s jediným sloupcem}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x
## 1 1
## 2 2
## 3 3
## 4 4
## 5 5
## 6 6
## 7 7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, }\StringTok{"x"}\NormalTok{]              }\CommentTok{\# vektor prvních dvou hodnot z vektoru x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{]                }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{, drop }\OtherTok{=} \ConstantTok{FALSE}\NormalTok{]  }\CommentTok{\# tabulka složená z prvních dvou hodnot vektoru x}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x
## 1 1
## 2 2
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{]              }\CommentTok{\# tabulka složená z prvních dvou řádků}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x y
## 1 1 3
## 2 2 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, }\FunctionTok{c}\NormalTok{(}\StringTok{"x"}\NormalTok{, }\StringTok{"y"}\NormalTok{)]      }\CommentTok{\# tabulka složená z prvních dvou řádků}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x y
## 1 1 3
## 2 2 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, ]                 }\CommentTok{\# tabulka složená z prvních dvou řádků}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x y
## 1 1 3
## 2 2 1
\end{verbatim}

Samozřejmě je možné použít i~indexování pomocí logických hodnot:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[d[, }\StringTok{"y"}\NormalTok{] }\SpecialCharTok{\textless{}} \DecValTok{7}\NormalTok{, ]  }\CommentTok{\# výběr řádků, kde je hodnota y menší než 7}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##       x  y
## 1     1  3
## 2     2  1
## NA   NA NA
## 5     5  5
## NA.1 NA NA
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[d}\SpecialCharTok{$}\NormalTok{y }\SpecialCharTok{\textless{}} \DecValTok{7}\NormalTok{ , ]      }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##       x  y
## 1     1  3
## 2     2  1
## NA   NA NA
## 5     5  5
## NA.1 NA NA
\end{verbatim}

Výběr zachová i řádky, kde je hodnota \(y\) \texttt{NA}. To jde vyřešit např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# vybíráme pouze prvky, kde y zároveň není NA a zároveň je menší než 7 nebo}
\NormalTok{d[}\SpecialCharTok{!}\FunctionTok{is.na}\NormalTok{(d}\SpecialCharTok{$}\NormalTok{y) }\SpecialCharTok{\&}\NormalTok{ d}\SpecialCharTok{$}\NormalTok{y }\SpecialCharTok{\textless{}} \DecValTok{7}\NormalTok{, ]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x y
## 1 1 3
## 2 2 1
## 5 5 5
\end{verbatim}

K~vyřazení neúplných hodnot z~tabulky a podobných struktur slouží funkce \texttt{complete.cases()}. V~případě tabulky vrací vektor logických hodnot, který je \texttt{TRUE} pro každý řádek tabulky, který má všechny hodnoty známé, a~\texttt{FALSE} jinak.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{complete.cases}\NormalTok{(d)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  TRUE  TRUE FALSE  TRUE  TRUE  TRUE FALSE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\FunctionTok{complete.cases}\NormalTok{(d), ]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x  y
## 1 1  3
## 2 2  1
## 4 4  7
## 5 5  5
## 6 6 12
\end{verbatim}

Pro složitější výběry z~tabulek existuje funkce \texttt{subset()}. Té však nebudeme věnovat pozornost, protože se později naučíte mnohem příjemnější a rychlejší funkce implementované v~balíku \textbf{dplyr}, viz~kapitola~\ref{kap:dplyr}.

Do existující tabulky přidáte novou proměnnou (nový sloupec) tak, že do nové proměnné přidáte hodnoty vektoru:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d}\SpecialCharTok{$}\NormalTok{z }\OtherTok{\textless{}{-}}\NormalTok{ letters[}\DecValTok{1}\SpecialCharTok{:}\FunctionTok{nrow}\NormalTok{(d)]}
\NormalTok{d}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x  y z
## 1 1  3 a
## 2 2  1 b
## 3 3 NA c
## 4 4  7 d
## 5 5  5 e
## 6 6 12 f
## 7 7 NA g
\end{verbatim}

Nová proměnná se přidá jako poslední sloupec.

Pokud do existující proměnné přiřadíte hodnotu \texttt{NULL}, vyřadíte tím proměnnou z~tabulky:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d}\SpecialCharTok{$}\NormalTok{z }\OtherTok{\textless{}{-}} \ConstantTok{NULL}
\NormalTok{d}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   x  y
## 1 1  3
## 2 2  1
## 3 3 NA
## 4 4  7
## 5 5  5
## 6 6 12
## 7 7 NA
\end{verbatim}

Jiná možnost, jak vynechat proměnnou nebo změnit jejich pořadí, je využít subsetování sloupců tabulky.

Subsetování jde použít i~ke změně pořadí řádků nebo sloupců. Řekněme, že chceme řádky tabulky~\texttt{d} seřadit podle proměnné~``y'' a zároveň vyměnit pořadí sloupců. To můžeme udělat např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\FunctionTok{order}\NormalTok{(d}\SpecialCharTok{$}\NormalTok{y), }\DecValTok{2}\SpecialCharTok{:}\DecValTok{1}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##    y x
## 2  1 2
## 1  3 1
## 5  5 5
## 4  7 4
## 6 12 6
## 3 NA 3
## 7 NA 7
\end{verbatim}

Hodnoty \texttt{NA} skončí implicitně na konci (jde změnit ve funkci \texttt{order()}).

\hypertarget{tabulky-tux159uxeddy-tibble}{%
\section{\texorpdfstring{Tabulky třídy \emph{tibble}}{Tabulky třídy tibble}}\label{tabulky-tux159uxeddy-tibble}}

Kromě tabulek třídy \emph{data.frame} existuje v~R ještě několik dalších typů tabulek. Nejpohodlnější z~nich je třída \emph{tibble}, která je součástí \textbf{tidyverse}, skupiny balíků určených pro datovou analýzu, kterými se budeme zabývat v~pozdějších částech tohoto textu. Tato třída tabulek má některé velmi příjemné vlastnosti, pro které je programování s~tabulkami třídy \emph{tibble} pohodlnější než programování s~tabulkami třídy \emph{data.frame}.

Tabulku třídy \emph{tibble} vytvoříte pomocí funkce \texttt{tibble()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(tibble)}
\NormalTok{ds }\OtherTok{\textless{}{-}} \FunctionTok{tibble}\NormalTok{(}\AttributeTok{x =} \DecValTok{1}\SpecialCharTok{:}\FloatTok{1e6}\NormalTok{, }\AttributeTok{y =} \DecValTok{2} \SpecialCharTok{*}\NormalTok{ x, }\AttributeTok{zed =}\NormalTok{ x }\SpecialCharTok{/} \DecValTok{3} \SpecialCharTok{+} \FloatTok{1.5} \SpecialCharTok{*}\NormalTok{ y }\SpecialCharTok{{-}} \DecValTok{7}\NormalTok{)}
\NormalTok{ds}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1,000,000 x 3
##        x     y    zed
##    <int> <dbl>  <dbl>
##  1     1     2 -3.67 
##  2     2     4 -0.333
##  3     3     6  3    
##  4     4     8  6.33 
##  5     5    10  9.67 
##  6     6    12 13    
##  7     7    14 16.3  
##  8     8    16 19.7  
##  9     9    18 23    
## 10    10    20 26.3  
## # ... with 999,990 more rows
\end{verbatim}

Pokud potřebujete vytvořit tabulku třídy \emph{tibble} ručně, existuje i~příjemná funkce \texttt{tribble()}, která umožňuje zadávat data po řádcích:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{tribble}\NormalTok{(}
    \SpecialCharTok{\textasciitilde{}}\NormalTok{name, }\SpecialCharTok{\textasciitilde{}}\NormalTok{weight, }\SpecialCharTok{\textasciitilde{}}\NormalTok{height,}
    \StringTok{"Adam"}\NormalTok{, }\DecValTok{68}\NormalTok{, }\DecValTok{193}\NormalTok{,}
    \StringTok{"Bětka"}\NormalTok{, }\DecValTok{55}\NormalTok{, }\DecValTok{163}\NormalTok{,}
    \StringTok{"Cyril"}\NormalTok{, }\DecValTok{103}\NormalTok{, }\DecValTok{159}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 3
##   name  weight height
##   <chr>  <dbl>  <dbl>
## 1 Adam      68    193
## 2 Bětka     55    163
## 3 Cyril    103    159
\end{verbatim}

Ke konverzi jiných tříd na \emph{tibble} slouží funkce \texttt{as\_tibble()}.

Vytvoření \emph{tibble} se od vytvoření \emph{data.frame} v~několika ohledech liší: \emph{tibble}

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  nemění ``nepovolená'' jména sloupců na povolená nahrazením divných znaků tečkami,
\item
  vyhodnocuje své argumenty postupně, takže můžete později zadaný argument použít při tvorbě dříve zadaného argumentu (jako v~příkladu výše),
\item
  podporuje jen omezenou recyklaci: všechny zadané vektory musejí mít buď stejnou délku, nebo délku~1,
\item
  nepoužívá jména řádků (která jsou ostatně nebezpečná k~uchovávání dat) a
\item
  převod na \emph{tibble} pomocí \texttt{as\_tibble()} je rychlejší než převod na \emph{data.frame} pomocí \texttt{as.data.frame()}.
\end{enumerate}

Liší se také to, jak \emph{tibble} vypisuje svou hodnotu do konzole. Oproti \emph{data.frame} zobrazí \emph{tibble} navíc rozměr tabulky a typ jednotlivých proměnných. Naopak vypíše jen prvních deset řádků a jen takový počet sloupců, které se vejdou na obrazovku. Počet vypsaných řádků je možné ovlivnit ve funkci \texttt{print()} pomocí parametru~\texttt{n}; počet sloupců pomocí parametru~\texttt{width}, kde \texttt{width} je maximální počet znaků, které může \emph{tibble} při tisku použít:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(ds, }\AttributeTok{n =} \DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1,000,000 x 3
##       x     y    zed
##   <int> <dbl>  <dbl>
## 1     1     2 -3.67 
## 2     2     4 -0.333
## 3     3     6  3    
## 4     4     8  6.33 
## 5     5    10  9.67 
## # ... with 999,995 more rows
\end{verbatim}

Hlavní rozdíl mezi \emph{tibble} a \emph{data.frame} se však týká subsetování: \emph{tibble} má konzistentnější chování a (na rozdíl od \emph{data.frame}) vrací vždy stejnou datovou strukturu, což je výhodné zejména při programování. \emph{tibble} nikdy nezahazuje zbytečné rozměry a ani je nepřidává. To znamená, že \texttt{{[}{]}} vždy vrací \emph{tibble}, zatímco \texttt{{[}{[}{]}{]}} a \texttt{\$} vždy vrací vektor. Navíc \emph{tibble} nikdy nepodporuje partial matching:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ds }\OtherTok{\textless{}{-}}\NormalTok{ ds[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{6}\NormalTok{, ]  }\CommentTok{\# omezíme ds na prvních 6 řádků}
\NormalTok{ds[, }\DecValTok{1}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 1
##       x
##   <int>
## 1     1
## 2     2
## 3     3
## 4     4
## 5     5
## 6     6
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ds[[}\DecValTok{1}\NormalTok{]]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3 4 5 6
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ds}\SpecialCharTok{$}\NormalTok{z}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning: Unknown or uninitialised column: `z`.
\end{verbatim}

\begin{verbatim}
## NULL
\end{verbatim}

Tato příjemná konzistence má však i~svá nebezpečí. Technicky je \emph{tibble} (stejně jako \emph{data.frame}) seznamem vektorů. Přestože jsme zatím vždy uvažovali atomické vektory, ve skutečnosti mohou být sloupci \emph{tibble} i~seznamy. To znamená, že následují kód ošklivě selže, protože do proměnné vloží celou tabulku:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ds }\OtherTok{\textless{}{-}} \FunctionTok{tibble}\NormalTok{(}\AttributeTok{a =} \DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\AttributeTok{b =} \DecValTok{11}\SpecialCharTok{:}\DecValTok{13}\NormalTok{)}
\NormalTok{ds}\SpecialCharTok{$}\NormalTok{c }\OtherTok{\textless{}{-}}\NormalTok{ ds[, }\StringTok{"a"}\NormalTok{]  }\CommentTok{\# vybere se tibble s jedním sloupcem a vloží do sloupce b}
\NormalTok{ds}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 3
##       a     b   c$a
##   <int> <int> <int>
## 1     1    11     1
## 2     2    12     2
## 3     3    13     3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ds}\SpecialCharTok{$}\NormalTok{c}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 1
##       a
##   <int>
## 1     1
## 2     2
## 3     3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{class}\NormalTok{(ds}\SpecialCharTok{$}\NormalTok{c)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "tbl_df"     "tbl"        "data.frame"
\end{verbatim}

Správný postup je opět použít operátor, který z~dat vybere jeden sloupec:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ds}\SpecialCharTok{$}\NormalTok{d }\OtherTok{\textless{}{-}}\NormalTok{ ds}\SpecialCharTok{$}\NormalTok{a}
\NormalTok{ds}\SpecialCharTok{$}\NormalTok{e }\OtherTok{\textless{}{-}}\NormalTok{ ds[[}\StringTok{"a"}\NormalTok{]]}
\NormalTok{ds}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 5
##       a     b   c$a     d     e
##   <int> <int> <int> <int> <int>
## 1     1    11     1     1     1
## 2     2    12     2     2     2
## 3     3    13     3     3     3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{class}\NormalTok{(ds}\SpecialCharTok{$}\NormalTok{d)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "integer"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{class}\NormalTok{(ds}\SpecialCharTok{$}\NormalTok{e)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "integer"
\end{verbatim}

Možnost využívající dvojité hranaté závorky se hodí zejména v~případě, kdy máte jméno sloupce uložené v~nějaké proměnné, takže je nemůžete zapsat přímo:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{name }\OtherTok{\textless{}{-}} \StringTok{"a"}
\NormalTok{ds}\SpecialCharTok{$}\NormalTok{f }\OtherTok{\textless{}{-}}\NormalTok{ ds[[name]]}
\NormalTok{ds}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 6
##       a     b   c$a     d     e     f
##   <int> <int> <int> <int> <int> <int>
## 1     1    11     1     1     1     1
## 2     2    12     2     2     2     2
## 3     3    13     3     3     3     3
\end{verbatim}

Někdy se nehodí pracovat s~\emph{tibble} (např.~proto, že některé funkce očekávají jiný výsledek subsetování). V~takovém případě můžete \emph{tibble} převést na \emph{data.frame} pomocí konverzní funkce \texttt{as.data.frame()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.data.frame}\NormalTok{(ds)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning in format.data.frame(if (omit) x[seq_len(n0), , drop = FALSE] else x, :
## corrupt data frame: columns will be truncated or padded with NAs
\end{verbatim}

\begin{verbatim}
##   a  b                 c d e f
## 1 1 11 # A tibble: 3 x 1 1 1 1
## 2 2 12                 a 2 2 2
## 3 3 13             <int> 3 3 3
\end{verbatim}

\hypertarget{sec:pipes}{%
\section{\texorpdfstring{Operátor trubka (\texttt{\textbar{}\textgreater{}} a \texttt{\%\textgreater{}\%})}{Operátor trubka (\textbar\textgreater{} a \%\textgreater\%)}}\label{sec:pipes}}

Při datové analýze se často hodí používat operátor ``trubka''. R~má dnes dvě základní verze tohoto operátoru: operátor~\texttt{\textbar{}\textgreater{}}, který je součástí základního~R (od verze~4.1) a operátor~\texttt{\%\textgreater{}\%} definovaný v~balíku \textbf{magrittr} (načtou jej však i~některé další balíky, jako např.~\textbf{dplyr}). RStudio zavádí pro ``trubku'' speciální klávesovou zkratku \texttt{Ctrl-Shift-M}. V~menu \texttt{Tools}\(\rightarrow\)\texttt{Global\ Options...}\(\rightarrow\)\texttt{Code}\(\rightarrow\)\texttt{Editing} si můžete vybrat, zda se použije nativní verze, nebo verze z~balíku \textbf{magrittr}.

Trubka umožňuje zapsat výraz se složitě zanořenými funkcemi poněkud čitelnějším způsobem. Řekněme např., že chceme na proměnnou \texttt{x} aplikovat funkci~\texttt{f()} a na výsledek funkci~\texttt{g()}. Standardním způsobem bychom to provedli takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{g}\NormalTok{(}\FunctionTok{f}\NormalTok{(x))}
\end{Highlighting}
\end{Shaded}

Operátor trubka umožní výraz přepsat do čitelnější podoby:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(magrittr)}
\NormalTok{x }\SpecialCharTok{|}\ErrorTok{\textgreater{}} \FunctionTok{f}\NormalTok{() }\SpecialCharTok{|}\ErrorTok{\textgreater{}} \FunctionTok{g}\NormalTok{()  }\CommentTok{\# nebo}
\NormalTok{x }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{f}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{g}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

Tato syntaxe lépe vystihuje to, co chceme provést. Doslova říká: vezmi proměnnou \texttt{x} a vlož ji jako první argument do funkce~\texttt{f()}. Výsledek vlož jako první argument do funkce~\texttt{g()}. Výrazy \texttt{x\ \textbar{}\textgreater{}\ f()} a \texttt{x\ \%\textgreater{}\%\ f()} jsou tedy ekvivalentní výrazu \texttt{f(x)}.
Funkce \texttt{f()} a \texttt{g()} samozřejmě mohou obsahovat i~další parametry. Ty se zařadí za proměnnou~\texttt{x}, takže \texttt{x\ \textbar{}\textgreater{}\ mean(na.rm\ =\ TRUE)} je ekvivalentní výrazu \texttt{mean(x,\ na.rm\ =\ TRUE)}; stejně tak výraz s~\texttt{\%\textgreater{}\%}.

Mnoho funkcí, se kterými budeme pracovat, je přizpůsobeno používání trubek, takže data do nich vstupují jako první argument. Některé funkce však berou data na jiné pozici. V~takovém případě není možné použít základní operátor~\texttt{\textbar{}\textgreater{}}, který dosadí výraz na levé straně vždy na první pozici funkce na pravé straně. Verze~\texttt{\%\textgreater{}\%} z~balíku \textbf{magrittr} umožňuje toto omezení obejít pomocí speciální proměnné tečka (\texttt{.}). Do té trubka vloží vstupní data. Díky tomu je možné zapsat výraz \texttt{f(y,\ x)} jako \texttt{x\ \%\textgreater{}\%\ f(y,\ .)} a \texttt{f(y,\ z\ =\ x)} jako \texttt{x\ \%\textgreater{}\%\ f(y,\ z\ =\ .)}.

Pozor: Pokud je speciální proměnná tečka použita ve funkci přímo, pak trubka nevloží proměnnou~\texttt{x} na první místo ve funkci (jak jsme to viděli v~předchozích případech). Pokud je však tečka použita jako součást nějakého výrazu, pak trubka proměnnou~\texttt{x} na první místo ve funkci vloží! To znamená, že \texttt{x\ \%\textgreater{}\%\ f(y\ =\ nrow(.),\ z\ =\ ncol(.))} je ekvivalentní s~\texttt{f(x,\ y\ =\ nrow(x),\ z\ =\ ncol(x))}. Pokud tomu chcete zabránit, musíte funkci~\texttt{f()} uzavřít do bloku. Takže \texttt{f(y\ =\ nrow(x),\ z\ =\ ncol(x))} musíme zapsat pomocí trubky jako \texttt{x\ \%\textgreater{}\%\ \{f(y\ =\ nrow(.),\ z\ =\ ncol(.))\}}.

Podívejme se na typický příklad použití trubek. Řekněme, že máme tabulku~\texttt{df} (zde si ji nasimulujeme) a chceme pro každou unikátní hodnotu identifikátoru~\texttt{x} spočítat průměrné hodnoty proměnných~\texttt{y} a \texttt{z}. To můžeme udělat např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(tibble)}
\FunctionTok{library}\NormalTok{(dplyr)}
\NormalTok{df }\OtherTok{\textless{}{-}} \FunctionTok{tribble}\NormalTok{(}
    \SpecialCharTok{\textasciitilde{}}\NormalTok{x, }\SpecialCharTok{\textasciitilde{}}\NormalTok{y, }\SpecialCharTok{\textasciitilde{}}\NormalTok{z,}
     \DecValTok{1}\NormalTok{,  }\DecValTok{1}\NormalTok{,  }\DecValTok{1}\NormalTok{,}
     \DecValTok{1}\NormalTok{,  }\DecValTok{2}\NormalTok{,  }\DecValTok{3}\NormalTok{,}
     \DecValTok{2}\NormalTok{,  }\DecValTok{3}\NormalTok{,  }\DecValTok{5}\NormalTok{,}
     \DecValTok{2}\NormalTok{,  }\DecValTok{4}\NormalTok{,  }\DecValTok{6}\NormalTok{,}
     \DecValTok{3}\NormalTok{,  }\DecValTok{5}\NormalTok{,  }\DecValTok{7}
\NormalTok{)}
\CommentTok{\# df |\textgreater{} group\_by(x) |\textgreater{} summarize(my = mean(y), mz = mean(z)) nebo}
\NormalTok{df }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{group\_by}\NormalTok{(x) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{summarize}\NormalTok{(}\AttributeTok{my =} \FunctionTok{mean}\NormalTok{(y), }\AttributeTok{mz =} \FunctionTok{mean}\NormalTok{(z))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 3
##       x    my    mz
##   <dbl> <dbl> <dbl>
## 1     1   1.5   2  
## 2     2   3.5   5.5
## 3     3   5     7
\end{verbatim}

Detaily fungování tohoto kódu si vysvětlíme v~kapitole \ref{kap:dplyr}. Nyní nás zajímá jen fungování trubek: proměnná~\texttt{df} se nejdříve vloží do funkce \texttt{group\_by()} a vyhodnotí se jako \texttt{group\_by(df,\ x)}. Výsledek této operace se pak vloží na první místo do funkce~\texttt{summarize()} a vyhodnotí se jako \texttt{summarize(.,\ my\ =\ mean(y),\ mz\ =\ mean(z))}, kde tečka označuje výsledek předchozího výpočtu, tj.~funkce~\texttt{group\_by()}.

Balík \textbf{magrittr} definuje i~některé další operátory. Seznámit se s~nimi můžete na webu balíku \url{http://magrittr.tidyverse.org/} a v~kapitole ``Pipes'' ve~\citet{WickhamRfDS} dostupné na \url{http://r4ds.had.co.nz/pipes.html}. Doporučuji však omezit se více méně jen na základní operátory~\texttt{\textbar{}\textgreater{}} a \texttt{\%\textgreater{}\%}.

\hypertarget{poznuxe1mka-k-doplux148ovuxe1nuxed-hodnot-do-tabulek}{%
\section{Poznámka k~doplňování hodnot do tabulek}\label{poznuxe1mka-k-doplux148ovuxe1nuxed-hodnot-do-tabulek}}

Stejně jako v~případě ostatních základních datových struktur v~R, je i~v~případě tabulek možné přiřadit novou hodnotu do výběru. To se hodí např.~v~situaci, kdy potřebujete nějakou hodnotu opravit nebo aktualizovat. Často se také hodí ukládat vypočtené nebo stahované hodnoty do tabulky. V~tomto posledním případě je však potřeba jisté opatrnosti, protože ukládání do výběru tabulky je výpočetně extrémně nákladná operace (kvůli nákladům na vyhledání dané hodnoty). V~případě malých tabulek to není problém, v~případě tabulek o~milionech řádků to už však může být problematické. Ukažme si to na příkladu (nenechte se vyvést z~míry tím, že nebudete rozumět všem detailům; většině porozumíte později v~tomto textu).

Nejdříve vytvoříme dva vektory o~délce 10~milionů hodnot, první celočíselný a druhý reálný. Vektory naplníme chybějícími hodnotami~\texttt{NA}. Vytvoříme i~dvě tabulky, které naplníme těmito vektory. První tabulka bude třídy \emph{data.frame}, druhá třídy \emph{tibble}. Náš test spočívá v~tom, že do každého vektoru budeme chtít vložit na stejnou pozici jedničku. Funkce \texttt{microbenchmark()} ze stejnojmenného balíku nám změří, jak dlouho bude tato operace trvat.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(microbenchmark)}
\FunctionTok{library}\NormalTok{(dplyr)}
\FunctionTok{library}\NormalTok{(tibble)}

\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{rep}\NormalTok{(}\ConstantTok{NA\_integer\_}\NormalTok{, }\FloatTok{1e7}\NormalTok{)}
\NormalTok{y }\OtherTok{\textless{}{-}} \FunctionTok{rep}\NormalTok{(}\ConstantTok{NA\_real\_}\NormalTok{, }\FloatTok{1e7}\NormalTok{)}
\NormalTok{df }\OtherTok{\textless{}{-}} \FunctionTok{data.frame}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{dt }\OtherTok{\textless{}{-}} \FunctionTok{tibble}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}

\NormalTok{performance }\OtherTok{\textless{}{-}} \FunctionTok{microbenchmark}\NormalTok{(}\StringTok{"vektory"} \OtherTok{=}\NormalTok{ \{x[}\DecValTok{1000}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 1L; y[}\DecValTok{1000}\NormalTok{] }\OtherTok{\textless{}{-}} \DecValTok{1}\NormalTok{\},}
                              \StringTok{"data.frame 1"} \OtherTok{=}\NormalTok{ \{df[}\DecValTok{1000}\NormalTok{, }\StringTok{"x"}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 1L; df[}\DecValTok{1000}\NormalTok{, }\StringTok{"y"}\NormalTok{] }\OtherTok{\textless{}{-}} \DecValTok{1}\NormalTok{\},}
                              \StringTok{"data.frame 2"} \OtherTok{=}\NormalTok{ \{df}\SpecialCharTok{$}\NormalTok{x[}\DecValTok{1000}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 1L; df}\SpecialCharTok{$}\NormalTok{y[}\DecValTok{1000}\NormalTok{] }\OtherTok{\textless{}{-}} \DecValTok{1}\NormalTok{\},}
                              \StringTok{"data.frame 3"} \OtherTok{=}\NormalTok{ df[}\DecValTok{1000}\NormalTok{, ] }\OtherTok{\textless{}{-}} \FunctionTok{data.frame}\NormalTok{(}\AttributeTok{x =}\NormalTok{ 1L, }\AttributeTok{y =} \DecValTok{1}\NormalTok{),}
                              \StringTok{"tibble 1"} \OtherTok{=}\NormalTok{ \{dt[}\DecValTok{1000}\NormalTok{, }\StringTok{"x"}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 1L; dt[}\DecValTok{1000}\NormalTok{, }\StringTok{"y"}\NormalTok{] }\OtherTok{\textless{}{-}} \DecValTok{1}\NormalTok{\},}
                              \StringTok{"tibble 2"} \OtherTok{=}\NormalTok{ \{dt}\SpecialCharTok{$}\NormalTok{x[}\DecValTok{1000}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 1L; dt}\SpecialCharTok{$}\NormalTok{y[}\DecValTok{1000}\NormalTok{] }\OtherTok{\textless{}{-}} \DecValTok{1}\NormalTok{\},}
                              \StringTok{"tibble 3"} \OtherTok{=}\NormalTok{ dt[}\DecValTok{1000}\NormalTok{, ] }\OtherTok{\textless{}{-}} \FunctionTok{tibble}\NormalTok{(}\AttributeTok{x =}\NormalTok{ 1L, }\AttributeTok{y =} \DecValTok{1}\NormalTok{),}
                              \AttributeTok{unit =} \StringTok{"ms"}\NormalTok{) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{summary}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{select}\NormalTok{(expr, min, mean, median, max)}
\end{Highlighting}
\end{Shaded}

\begin{table}

\caption{\label{tab:performance-test-inkluze}Čas potřebný na vložení dvou hodnot do vektorů a tabulek v milisekundách.}
\centering
\begin{tabular}[t]{l|r|r|r|r}
\hline
expr & min & mean & median & max\\
\hline
vektory & 0.001053 & 0.4667597 & 0.007912 & 45.96344\\
\hline
data.frame 1 & 44.554692 & 55.6054760 & 45.947955 & 111.86176\\
\hline
data.frame 2 & 29.668678 & 46.2643428 & 45.289116 & 110.15821\\
\hline
data.frame 3 & 44.648180 & 56.5273230 & 45.845424 & 118.66232\\
\hline
tibble 1 & 90.389274 & 108.9380412 & 98.423906 & 198.29275\\
\hline
tibble 2 & 44.656020 & 55.5125589 & 46.269412 & 113.05652\\
\hline
tibble 3 & 90.675843 & 109.1186367 & 99.438728 & 159.77929\\
\hline
\end{tabular}
\end{table}

Výsledky jsou dramatické, jak ukazuje tabulka~\ref{tab:performance-test-inkluze}. Vložení dvou hodnot do tabulek trvá (na mém poměrně výkonném počítači) v~průměru několik desítek milisekund, zatímco vložení do vektoru trvá na stejném počítači tisíciny milisekund (pokud se díváme na mediány).
Praktický výsledek je zřejmý: pokud vkládáte do tabulky jednotlivé hodnoty, nevadí to, pokud je tabulka malá nebo vkládáte jen velmi málo hodnot. V~opačném případě se výrazně vyplatí pracovat s~vektory.
Jednou jsem potřeboval zjistit vzdálenosti vzdušnou čarou mezi asi 5~000 čerpacími stanicemi. Bylo tedy potřeba spočítat a uložit asi 12~milionů vzdáleností (vzdálenost vzdušnou čarou je symetrická). Vlastní výpočet vzdálenosti je extrémně rychlý. Přesto však celý výpočet neskončil ani za čtyři dny~-- spočítalo se asi jen 1.5~milionu hodnot. Na vině bylo to, že jsem doplňoval hodnoty přímo do tabulky. Když jsem kód přepsal tak, aby pracoval s~vektory, které jsem spojil do tabulky až nakonec, výpočet proběhl zhruba za půl hodiny.

Všimněte si také toho, že jsem vektory a tabulky celé předalokoval. Kdybychom chtěli datové struktury zvětšovat postupně přidáváním dalších a dalších hodnot nebo řádků, byl by výpočet ještě pomalejší, protože by R muselo neustále alokovat nové bloky paměti a do nich nejdříve překopírovat stará data, a~teprve potom přidat nové hodnoty. To by se opakovalo při každém zvětšení vektoru nebo tabulky.

Pokud se chcete dozvědět víc o~efektivnosti kódu v~R, doporučuji zejména \citet{WickhamAdvR}, kap.~Performance a Profiling. Užitečné je také \citet{RInferno}.

\hypertarget{volba-datovuxe9-struktury}{%
\section{Volba datové struktury}\label{volba-datovuxe9-struktury}}

Vstupní data pro jakoukoli analýzu budou mít ve většině případů formát tabulky. Naproti tomu si strukturu dat, která vzniknou transformacemi původních dat, můžete zvolit sami. Tuto strukturu byste si měli dopředu pořádně rozmyslet. Vhodně zvolená struktura vám umožní s~daty pracovat jednoduše; špatně zvolená struktura může v~následné práci dělat problémy.

Ve většině případů doporučuji používat pro uschování jakýchkoli dat tabulky (nejlépe třídy \emph{tibble}). Oproti jiným strukturám mají několik výhod: 1)~snadno se ukládají, čtou a převádí do jiného software, 2)~snadno se z~nich dělají výběry, 3)~snadno se transformují a 4)~snadno se vizualizují, ať už jako tabulky nebo v~grafech. R~nabízí mnoho balíků pro transformace tabulek (zejména \textbf{tidyr} a \textbf{dplyr}) a pro jejich vizualizaci (zejména \textbf{ggplot2}); o~těchto balících bude řeč později. Práce s~ostatními datovými strukturami je mnohem méně standardizovaná, takže si víc kódu budete muset napsat sami.

Použití jiné datové struktury k~úschově dat má smysl pouze ve speciálních situacích: 1)~pokud jinou strukturu (typicky vektory nebo matice) vyžadují použité funkce jako své vstupy, 2)~když potřebujete rychlou maticovou aritmetiku a 3)~když jsou složitější objekty výsledkem výpočtů (např.~modelové objekty v~ekonometrii). Pro dočasnou úschovu nehomogenních dat se hodí i~seznamy, které typicky vznikají iteracemi nad vektory. Přesto vám výrazně doporučuji, abyste si pokaždé, když budete chtít zvolit jinou datovou strukturu než tabulku, tuto volbu raději několikrát promysleli.

\hypertarget{speciuxe1lnuxed-datovuxe9-typy}{%
\chapter{Speciální datové typy}\label{speciuxe1lnuxed-datovuxe9-typy}}

Kromě základních datových typů existují v~R i~další datové typy, které jsou implementované jako třídy objektů (o~nich se více dozvíte v~kapitole~\ref{kap:objekty}). Z~nich nejdůležitější jsou faktory a třídy pro uchovávání datumů a času. Všechny tyto typy jsou implementovány jako rozšíření datových typů integer nebo double.

V~této kapitole se naučíte

\begin{itemize}
\tightlist
\item
  vytvářet, používat a měnit faktory a
\item
  základy práce s~datumy a časem
\end{itemize}

\hypertarget{sec:factors}{%
\section{Faktory}\label{sec:factors}}

Faktory slouží k~uchovávání kategoriálních proměnných. Kategoriální proměnné jsou proměnné, kterou mohou nabývat jen určitých předem stanovených úrovní. Tyto úrovně mohou být buď uspořádané (pak se jedná o~ordinální proměnné), nebo neuspořádané. Příkladem ordinální kategoriální proměnné je kvalita služeb zjišťovaná v~dotazníku. Ta může nabývat např.~hodnot ``velmi špatná'', ``špatná'', ``průměrná'', ``dobrá'' a ``výborná''. Jiné úrovně nejsou (v~rámci kódování dotazníku) možné. Přitom platí, že hodnoty jsou uspořádané od nejhorší po nejlepší, takže vždy můžeme dvě úrovně porovnat a říci, která je lepší. Příkladem neordinální kategoriální proměnné je např.~pohlaví, které může nabývat hodnot ``žena'' nebo ``muž''. Na rozdíl od předchozího případu zde není jasné pořadí, ve kterém by měly být hodnoty uspořádány.

Kategoriální proměnné je možné kódovat např.~jako celá čísla: např.~muž bude~0 a žena~1, nejhorší kvalita služby bude~0, druhá nejhorší~1 atd. To však není dobrý nápad hned z~několika důvodů: 1)~je obtížné pamatovat si, co která hodnota znamená, 2)~R~nebude vědět, jak s~takovými proměnnými zacházet a bude je považovat za kardinální veličiny (tj.~bude např.~kvalitu služby ``průměrnou'' kódovanou jako~2 považovat za dvakrát lepší než kvalitu ``špatnou'' kódovanou jako~1, přestože jediné, co víme, je, že ``průměrná'' kvalita je lepší než ``špatná'', ale už ne o~kolik nebo kolikrát) a 3)~R nebude schopné hlídat, zda není zadána nesmyslná úroveň proměnné (např.~kvalita služby~7).
Faktory řeší všechny tyto problémy: jednotlivým hodnotám dávají ``nálepky'', které ukazují na jejich význam, a~zároveň říkají~R, že se jedná o~kategoriální proměnnou. Ve statistické analýze pak zachází s~faktory správně; v~ekonometrické analýze např.~automaticky vytvoří pro jednotlivé úrovně faktoru potřebné umělé proměnné. R~také zná platné úrovně faktorů a hlídá, zda je zadaná úroveň platná.

Faktory se tvoří pomocí funkce \texttt{factor()}. Ta vyžaduje nutně pouze vektor řetězců, který obsahuje hodnoty, které se mají na faktor převést:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"žena"}\NormalTok{, }\StringTok{"muž"}\NormalTok{, }\StringTok{"muž"}\NormalTok{, }\StringTok{"žena"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] žena muž  muž  žena
## Levels: muž žena
\end{verbatim}

V~tomto případě R~odhaduje úrovně faktoru z~dat, což není příliš bezpečné, protože v~konkrétním datovém vzorku může některá platná úroveň faktoru chybět a některá zadaná úroveň nemusí být platná (např.~kvůli chybě zapisovatele do dotazníků). Obecně je bezpečnější říct funkci \texttt{factor()} i~to, jakých hodnot může faktor nabývat (pomocí parametru \texttt{levels}). To umožní zadat i~hodnoty, které nyní zadaný vektor neobsahuje, ale obsahovat by je mohl, a~také určit pořadí faktorů, které R jinak řadí podle abecedy. (Pořadí úrovní je důležité zejména pro ordinální faktory. Ovšem i~u~neordinálních faktorů při některých statistických metodách určuje, která hodnota bude brána jako referenční úroveň.) Parametr~\texttt{labels} navíc umožňuje úrovně faktorů překódovat:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"male"}\NormalTok{, }\StringTok{"female"}\NormalTok{, }\StringTok{"female"}\NormalTok{, }\StringTok{"male"}\NormalTok{, }\StringTok{"female"}\NormalTok{),  }\CommentTok{\# hodnoty vektoru}
       \AttributeTok{levels =} \FunctionTok{c}\NormalTok{(}\StringTok{"female"}\NormalTok{, }\StringTok{"male"}\NormalTok{, }\StringTok{"asexual"}\NormalTok{),          }\CommentTok{\# možné úrovně}
       \AttributeTok{labels =} \FunctionTok{c}\NormalTok{(}\StringTok{"žena"}\NormalTok{, }\StringTok{"muž"}\NormalTok{, }\StringTok{"asexuální"}\NormalTok{))            }\CommentTok{\# co se bude vypisovat}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] muž  žena žena muž  žena
## Levels: žena muž asexuální
\end{verbatim}

Všimněte si, že při vypsání faktor vypisuje nejen hodnoty vektoru, nýbrž i~seznam hodnot, kterých mohou nabývat.

Pokud se pokusíte uložit do faktoru hodnotu, která neodpovídá zadaným úrovním, R~danou hodnotu tiše nahradí hodnotou~\texttt{NA}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"male"}\NormalTok{, }\StringTok{"female"}\NormalTok{, }\StringTok{"female"}\NormalTok{, }\StringTok{"male"}\NormalTok{, }\StringTok{"beaver"}\NormalTok{),  }\CommentTok{\# hodnoty vektoru}
       \AttributeTok{levels =} \FunctionTok{c}\NormalTok{(}\StringTok{"female"}\NormalTok{, }\StringTok{"male"}\NormalTok{, }\StringTok{"asexual"}\NormalTok{),          }\CommentTok{\# možné úrovně}
       \AttributeTok{labels =} \FunctionTok{c}\NormalTok{(}\StringTok{"žena"}\NormalTok{, }\StringTok{"muž"}\NormalTok{, }\StringTok{"asexuální"}\NormalTok{))            }\CommentTok{\# co se bude vypisovat}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] muž  žena žena muž  <NA>
## Levels: žena muž asexuální
\end{verbatim}

To je velmi šikovné, protože to umožňuje hlídat, zda jsou všechny hodnoty zadané správně. Řekněme, že svá data stahujete z~nějakého serveru, který s~vámi nespolupracuje a může kdykoli bez varování změnit kódování některých kategoriálních hodnot. Jedna možnost, jak to zjistit, je převádět je z~řetězců na faktory s~pevně zadanými hodnotami úrovní. Pokud se mezi hodnotami faktoru objeví \texttt{NA}, znamená to, že server změnil kódování dané proměnné.

Implicitně jsou všechny faktory ne-ordinální. Pokud chcete R~říci, že faktor je ordinální, přidáte parametr \texttt{ordered\ =\ TRUE}. Pak na faktory funguje porovnání větší a menší:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{quality }\OtherTok{\textless{}{-}} \FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"poor"}\NormalTok{, }\StringTok{"satisfactory"}\NormalTok{, }\StringTok{"excelent"}\NormalTok{),}
                  \AttributeTok{levels =} \FunctionTok{c}\NormalTok{(}\StringTok{"poor"}\NormalTok{, }\StringTok{"satisfactory"}\NormalTok{, }\StringTok{"excelent"}\NormalTok{),}
                  \AttributeTok{ordered =} \ConstantTok{TRUE}\NormalTok{)}
\NormalTok{quality}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] poor         satisfactory excelent    
## Levels: poor < satisfactory < excelent
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{quality[}\DecValTok{1}\NormalTok{] }\SpecialCharTok{\textless{}}\NormalTok{ quality[}\DecValTok{3}\NormalTok{]  }\CommentTok{\# quality[i] je i{-}tý prvek vektoru}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Funkce \texttt{is.ordered()} vrací logickou hodnotu \texttt{TRUE}, pokud je faktor ordinální.

Pozor! Pokud opravdu dobře nevíte, co děláte, používejte raději ne-ordinální faktory. Ordinální faktory se ve formulích (tj.~např.~v~ekonometrické analýze, viz kapitola~\ref{kap:ekonometrie}) chovají jinak, než byste možná čekali, viz \url{https://goo.gl/HY3uNf} a \url{https://goo.gl/F9Shll}, oddíl 11.1.1.

Hodnoty úrovní můžete získat pomocí funkce \texttt{levels()}; jejich počet pomocí funkce \texttt{nlevels()}. Funkce \texttt{levels()} umožňuje i~měnit hodnoty úrovní faktoru:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{f }\OtherTok{\textless{}{-}} \FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"female"}\NormalTok{, }\StringTok{"male"}\NormalTok{, }\StringTok{"female"}\NormalTok{))}
\NormalTok{f}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] female male   female
## Levels: female male
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{levels}\NormalTok{(f) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{)}
\NormalTok{f}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] a b a
## Levels: a b c
\end{verbatim}

\hypertarget{tvorba-faktoru-ze-spojituxe9-promux11bnnuxe9}{%
\subsection{Tvorba faktoru ze spojité proměnné}\label{tvorba-faktoru-ze-spojituxe9-promux11bnnuxe9}}

Někdy je užitečné rozdělit spojitou škálu do diskrétních hodnot, takže spojitou proměnnou změníte na ordinální faktor. Např.~můžeme chtít rozdělit studenty do tří kategorií podle jejich studijního průměru: na excelentní žáky (do průměru 1.2 včetně), běžné žáky (od průměru 1.2 do 2.5 včetně) a ostatní. K~tomu slouží funkce \texttt{cut()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{grades }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\FloatTok{1.05}\NormalTok{, }\FloatTok{3.31}\NormalTok{, }\FloatTok{2.57}\NormalTok{, }\FloatTok{1.75}\NormalTok{, }\FloatTok{2.15}\NormalTok{)  }\CommentTok{\# studijní průměry}
\NormalTok{students }\OtherTok{\textless{}{-}} \FunctionTok{cut}\NormalTok{(grades, }\AttributeTok{breaks =} \FunctionTok{c}\NormalTok{(}\DecValTok{0}\NormalTok{, }\FloatTok{1.2}\NormalTok{, }\FloatTok{2.5}\NormalTok{, }\ConstantTok{Inf}\NormalTok{), }\AttributeTok{right =} \ConstantTok{TRUE}\NormalTok{)}
\NormalTok{students}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] (0,1.2]   (2.5,Inf] (2.5,Inf] (1.2,2.5] (1.2,2.5]
## Levels: (0,1.2] (1.2,2.5] (2.5,Inf]
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{levels}\NormalTok{(students) }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"excelent"}\NormalTok{, }\StringTok{"normal"}\NormalTok{, }\StringTok{"rest"}\NormalTok{)}
\NormalTok{students}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] excelent rest     rest     normal   normal  
## Levels: excelent normal rest
\end{verbatim}

Změnu názvů úrovní je možné nastavit přímo ve funkci \texttt{cut()} parametrem \texttt{labels}. Detaily použití funkce \texttt{cut()} najdete v~dokumentaci funkce.

Jako mnoho jiných funkcí ve standardní výbavě~R má i~funkce \texttt{cut()} mnoho (na první pohled) složitých parametrů. Balík \textbf{ggplot2} nabízí tři specializovanějí funkce, které udělají stejnou práci jako \texttt{cut()}, ale jejich použití je jednodušší: \texttt{cut\_width()} nařeže původní proměnnou na úrovně s~danou šířkou, \texttt{cut\_interval()} na daný počet úrovní se stejnou šířkou a \texttt{cut\_number()} na daný počet úrovní se stejným počtem pozorování.

\hypertarget{pux159evod-faktorux16f-na-ux10duxedsla}{%
\subsection{Převod faktorů na čísla}\label{pux159evod-faktorux16f-na-ux10duxedsla}}

Faktory jsou užitečné, ale i~zrádné. Technicky jsou implementované jako vektor celých čísel, který má navíc pojmenované úrovně:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{unclass}\NormalTok{(}\FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"žena"}\NormalTok{, }\StringTok{"muž"}\NormalTok{, }\StringTok{"muž"}\NormalTok{, }\StringTok{"žena"}\NormalTok{)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2 1 1 2
## attr(,"levels")
## [1] "muž"  "žena"
\end{verbatim}

Při automatické konverzi se tedy může stát, že se faktor převede na celá čísla~-- svých úrovní. Většinou to nevadí, existují však zrádné situace, kdy název úrovně faktoru je složen z~číslic. Nejdříve si to ukážeme na poněkud legračním příkladu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{f }\OtherTok{\textless{}{-}} \FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"747"}\NormalTok{, }\StringTok{"737"}\NormalTok{, }\StringTok{"777"}\NormalTok{, }\StringTok{"747"}\NormalTok{))  }\CommentTok{\# vektor typů vašich letadel Boeing}
\NormalTok{f}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 747 737 777 747
## Levels: 737 747 777
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.integer}\NormalTok{(f)  }\CommentTok{\# chcete dostat zpět typy letadel, ale ouha! dostanete čísla úrovní!}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2 1 3 2
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.integer}\NormalTok{(}\FunctionTok{as.character}\NormalTok{(f))  }\CommentTok{\# je potřebná dvojí konverze!}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 747 737 777 747
\end{verbatim}

Realističtější situace vznikne, když faktory odpovídají nařezané spojité proměnné. Zde si ji vytvoříme, ale typicky už je taková proměnná obsažena v~datech:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{rnorm}\NormalTok{(}\DecValTok{100}\NormalTok{)  }\CommentTok{\# sto čísel náhodně vybraných z normovaného norm. rozdělení}
\NormalTok{h }\OtherTok{\textless{}{-}} \FunctionTok{cut}\NormalTok{(x,  }\CommentTok{\# faktor nařezaný od {-}10 po +10 po dvou, jméno binu je střed intervalu}
         \AttributeTok{breaks =} \FunctionTok{seq}\NormalTok{(}\AttributeTok{from =} \SpecialCharTok{{-}}\DecValTok{10}\NormalTok{, }\AttributeTok{to =} \DecValTok{10}\NormalTok{, }\AttributeTok{by =} \DecValTok{2}\NormalTok{),}
         \AttributeTok{labels =} \FunctionTok{seq}\NormalTok{(}\AttributeTok{from =} \SpecialCharTok{{-}}\DecValTok{9}\NormalTok{, }\AttributeTok{to =} \DecValTok{9}\NormalTok{, }\AttributeTok{by =} \DecValTok{2}\NormalTok{))}
\NormalTok{h}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   [1] 1  -1 -1 -1 -1 -1 -1 -1 1  1  -1 1  1  1  -1 1  -1 -1 1  -1 -1 1  -1 1  -1
##  [26] 1  -1 -1 1  -1 -1 -1 -1 -1 1  -1 -1 1  -1 -1 -1 -1 -1 1  -1 1  -1 1  1  -1
##  [51] 1  1  -1 1  1  1  1  1  -1 1  -1 -3 1  -1 1  1  1  -1 -1 -1 -1 -1 1  -1 1 
##  [76] -1 -1 -1 1  1  -1 -1 -1 -1 -1 -1 -1 -1 -1 1  1  1  1  -1 1  -1 1  1  1  -1
## Levels: -9 -7 -5 -3 -1 1 3 5 7 9
\end{verbatim}

Řekněme, že chceme spočítat průměrnou hodnotu pozorování a zkusíme to udělat takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{mean}\NormalTok{(}\FunctionTok{as.numeric}\NormalTok{(h))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 5.41
\end{verbatim}

V~našem případě bychom čekali výsledek někde kolem nuly, takže náš výsledek je očividně nesprávný. V~případě skutečných dat s~neznámým rozdělením si však nemusíte všimnout ničeho podezřelého. Chybný výsledek vznikl tak, že R prvně převedlo funkcí \texttt{as.numeric()} faktory na jejich úrovně označeného 1, 2 atd. a z~nich následně spočítalo průměr. To, co jsme chtěli dostat, bylo ve skutečnosti toto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{mean}\NormalTok{(}\FunctionTok{as.numeric}\NormalTok{(}\FunctionTok{as.character}\NormalTok{(h)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] -0.18
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{mean}\NormalTok{(}\FunctionTok{as.numeric}\NormalTok{(}\FunctionTok{levels}\NormalTok{(h)[h]))  }\CommentTok{\# totéž jinými slovy}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] -0.18
\end{verbatim}

\hypertarget{uxfapravy-faktorux16f}{%
\subsection{Úpravy faktorů}\label{uxfapravy-faktorux16f}}

Většinou pracujeme s~faktory tak, jak jsou. Někdy je však potřebujeme nějakým způsobem transformovat: vyřadit nepoužité úrovně, spojit různé faktory, přejmenovat jejich úrovně apod. Některé z~těchto úprav jsou překvapivě netriviální. Naštěstí existuje balík, který tyto úpravy zjednodušuje. Zde se podíváme jen na vybrané základní situace. Pro náročnější situace doporučujeme se podívat na dokumentaci balíku \textbf{forcats}.

Obvykle nejpotřebnější úpravou faktorů je vyřazení nepotřebných úrovní. Pokud totiž z~faktoru vybereme jen některá pozorování, zůstanou ve faktoru zachovány všechny úrovně, i~ty, kterým ve vektoru už neodpovídá žádné pozorování:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{h[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1  -1 -1 -1 -1
## Levels: -9 -7 -5 -3 -1 1 3 5 7 9
\end{verbatim}

Pokud chceme nepoužité úrovně vypustit, musíme operátoru hranatá závorka dát parametr \texttt{drop=TRUE}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{h[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, drop }\OtherTok{=} \ConstantTok{TRUE}\NormalTok{]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1  -1 -1 -1 -1
## Levels: -1 1
\end{verbatim}

Druhou častou úpravou je spojování dvou vektorů faktorů. Na první pohled by se mohlo zdát, že by mělo stačit použít funkci pro spojení atomických vektorů~\texttt{c()}. To však nebude fungovat, protože funkce \texttt{c()} převede faktory na celá čísla (jejich úrovně) a nálepky úrovní zahodí. Pokud se navíc úrovně faktorů liší, tento fakt bude zcela zapomenut:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{f1 }\OtherTok{\textless{}{-}} \FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{))}
\NormalTok{f2 }\OtherTok{\textless{}{-}} \FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"x"}\NormalTok{, }\StringTok{"y"}\NormalTok{, }\StringTok{"z"}\NormalTok{))}
\FunctionTok{c}\NormalTok{(f1, f2)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] a b c x y z
## Levels: a b c x y z
\end{verbatim}

Spojení faktorů je tedy třeba provést tak, že se před spojením faktory převedou na své úrovně a po spojení opět na faktory:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\FunctionTok{as.character}\NormalTok{(f1), }\FunctionTok{as.character}\NormalTok{(f2)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] a b c x y z
## Levels: a b c x y z
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{factor}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\FunctionTok{levels}\NormalTok{(f1)[f1], }\FunctionTok{levels}\NormalTok{(f2)[f2]))  }\CommentTok{\# totéž jinými slovy}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] a b c x y z
## Levels: a b c x y z
\end{verbatim}

Poslední obvyklou transformací faktorů je změna pořadí jejich úrovní. K~tomu existují v~principu dva důvody: Zaprvé, někdy potřebujeme nastavit referenční úroveň faktoru. Např.~v~ekonometrii R samo vytvoří pro jednotlivé úrovně faktoru potřebné umělé proměnné. Přitom samozřejmě jednu úroveň (referenční úroveň nebo také kontrast) vynechá. R~automaticky vynechává první úroveň. Pokud jsme nezadali jména úrovní explicitně, pak R vynechá tu úroveň, která je první v~abecedě. To však často není to, co chceme. Změnu referenční úrovně provedeme snadno pomocí funkce \texttt{relevel()}. Jejím první parametrem je faktor, druhým je nová referenční úroveň (všimněte si pořadí úrovní na konci výpisu faktoru):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{relevel}\NormalTok{(h, }\StringTok{"1"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   [1] 1  -1 -1 -1 -1 -1 -1 -1 1  1  -1 1  1  1  -1 1  -1 -1 1  -1 -1 1  -1 1  -1
##  [26] 1  -1 -1 1  -1 -1 -1 -1 -1 1  -1 -1 1  -1 -1 -1 -1 -1 1  -1 1  -1 1  1  -1
##  [51] 1  1  -1 1  1  1  1  1  -1 1  -1 -3 1  -1 1  1  1  -1 -1 -1 -1 -1 1  -1 1 
##  [76] -1 -1 -1 1  1  -1 -1 -1 -1 -1 -1 -1 -1 -1 1  1  1  1  -1 1  -1 1  1  1  -1
## Levels: 1 -9 -7 -5 -3 -1 3 5 7 9
\end{verbatim}

Zadruhé, někdy chceme seřadit úrovně faktorů podle nějaké charakteristiky dat~-- např.~proto, že pořadí úrovní ovlivňuje pořadí, ve kterém jsou data vykreslena v~grafu. Toto je překvapivě netriviální problém. Můžete použít bud základní funkci \texttt{reorder()}, která je velmi mocná, ale má poněkud komplikované ovládání, nebo přívětivější funkce z~balíku \textbf{forcats}. Návod na jejich použití najdete v~kapitole o~balíku **forcats* v~knize \citet{WickhamRfDS} dostupné také na \url{http://r4ds.had.co.nz/factors.html} nebo v~referenční příručce balíku, která je dostupná na \url{http://forcats.tidyverse.org/}.

\hypertarget{poznuxe1mka-k-faktorux16fm}{%
\subsection{Poznámka k faktorům}\label{poznuxe1mka-k-faktorux16fm}}

Historicky se faktory používaly velmi často, protože šetřily paměť počítače. Místo vektoru řetězců, kde se hodnoty často opakovaly, zbyl krátký vektor unikátních hodnot řetězců (úrovně \texttt{levels}) a paměťově úspornější vektor celých čísel, který říkal, která úroveň se právě používá. Dnes to však už není pravda: R~skladuje řetězce v~jednom velkém skladu, každý z~nich pouze jednou a vektory řetězců jsou implementovány jako odkazy do tohoto skladu. Prakticky to znamená, že převedením řetězců na faktory se žádná paměť neušetří.

Nicméně, z~těchto historických důvodů se funkce ze základních balíků R často snaží řetězce převádět na faktory. Příkladem takových funkcí jsou např.~funkce \texttt{data.frame()} a \texttt{read.csv()}, které historicky převáděly řetězce na faktory. Tomu šlo zabránit nastavením parametru \texttt{stringsAsFactors} na hodnotu \texttt{FALSE}. R~od verze 4.0 však tyto konverze v~těchto funkcích neprovádí. Pokud tedy chcete převést řetězec na faktor, musíte buď nastavit explicitně parametr \texttt{stringsAsFactors} na hodnotu \texttt{TRUE}, nebo převést proměnnou na faktor ručně pomocí funkce \texttt{factor()}, což je mnohem rozumnější.

\hypertarget{sec-datetime}{%
\section{Datum a čas}\label{sec-datetime}}

Datum a čas lze v~R ukládat do vektorů několika různých tříd. Z~nich jsou nejdůležitější jsou třídy \emph{Date} pro reprezentaci celých dnů bez času a \emph{POSIXct} pro reprezentaci dne i~hodiny. Datové typy \emph{Date} a \emph{POSIXct} nepatří mezi základní datové typy v~R, ale jedná se o~třídy objektů odvozené od tříd \emph{integer} a \emph{double}. První ukládá datum tak, že celé číslo reprezentuje počet dnů od 1.~ledna 1970, druhá reprezentuje čas jako počet sekund, které od tohoto dne uběhl. Při výpisu však obě funkce zobrazují datum uživatelsky přátelským způsobem.

R~nabízí pro práci s~datumy a časem několik užitečných funkcí, které však mohou být v~určitých situacích poněkud těžkopádné. Uživatelsky přívětivější funkce nabízí balík \textbf{lubridate}. Zde si ukážeme některé základní operace s~datumy a časem jak pomocí základních funkcí, tak pomocí funkcí z~balíku \textbf{lubridate}. Proto jej musíme nejprve načíst:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(lubridate)}
\end{Highlighting}
\end{Shaded}

\hypertarget{zaduxe1vuxe1nuxed-datumux16f-a-ux10dasu}{%
\subsection{Zadávání datumů a času}\label{zaduxe1vuxe1nuxed-datumux16f-a-ux10dasu}}

Datum nejčastěji vytvoříme konverzí z~řetězce. K~tomu slouží funkce \texttt{as.Date()}, která předpokládá, že řetězec obsahuje datum uložené ve formátu obvyklém v~anglofonním světě, kdy na prvním místě stojí rok, pak měsíc a nakonec den a jednotlivé položky jsou oddělené pomlčkou (tak R také datumy vypisuje):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.Date}\NormalTok{(}\StringTok{"2016{-}11{-}25"}\NormalTok{)  }\CommentTok{\# 25. listopadu 2016}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "2016-11-25"
\end{verbatim}

Pokud je datum zadáno v~jiném formátu, musíte tento formát popsat v~parametru \texttt{format}. Formát se zadává pomocí formátovacích řetězců, které jsou popsané v~dokumentaci funkce \texttt{strptime()}. Základní parametry uvádí tabulka~\ref{tab:dates-format}. Řekněme, že máme data zadaná ve formátu číslo dne, zkratka měsíce a rok, kde jednotlivé položky nejsou nijak oddělené. Pak bude mít řetězec formátu tvar ``\%d\%b\%Y'': ``\%d''~znamená, že na prvním místě je den v~měsíci, ``\%b''~říká, že na druhém místě je zkrácený název měsíce a ``\%Y'' že na posledním místě je rok zadaný čtyřmi číslicemi.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.Date}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"1led1960"}\NormalTok{, }\StringTok{"2led1960"}\NormalTok{, }\StringTok{"31bře1960"}\NormalTok{, }\StringTok{"30čec1960"}\NormalTok{), }\AttributeTok{format =} \StringTok{"\%d\%b\%Y"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "1960-01-01" "1960-01-02" "1960-03-31" "1960-07-30"
\end{verbatim}

\begin{longtable}[]{@{}ll@{}}
\caption{\label{tab:dates-format} Vybrané formátové značky pro zadávání datumu a času}\tabularnewline
\toprule
kód & význam \\
\midrule
\endfirsthead
\toprule
kód & význam \\
\midrule
\endhead
\%d & číslo dne v~měsíci \\
\%m & číslo měsíce v~roce \\
\%b & zkrácené jméno měsíce \\
\%B & plné jméno měsíce \\
\%y & rok zadaný dvěma číslicemi \\
\%Y & rok zadaný čtyřmi číslicemi \\
\%H & číslo hodiny (0--23) \\
\%M & číslo minuty (0--59) \\
\%S & číslo sekundy (0--61 pro přestupné vteřiny) \\
\bottomrule
\end{longtable}

Pokud by jednotlivé položky datumu byly nějak oddělené, zadaly by se tyto oddělovače do formátu. Datum ve formátu ``1. červen 1974'' by mělo formátový řetězec ``\%d.~\%B \%Y'':

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.Date}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"1. červen 1974"}\NormalTok{, }\StringTok{"17. listopad 1989"}\NormalTok{), }\AttributeTok{format =} \StringTok{"\%d. \%B \%Y"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] NA NA
\end{verbatim}

Jména měsíců a dnů v~týdnu standardně se berou z~lokalizace vašeho operačního systému. Pokud vám tato lokalizace nevyhovuje (potřebujete jména v~jiném jazyce) nebo musíte svůj kód přenášet mezi více počítači, můžete lokalizaci manuálně přepnout (víc detailů najdete v~dokumentaci k~\texttt{locales}: \texttt{?locales}):

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# nastav locales, aby jména dnů byla anglicky}
\CommentTok{\# (zde se tento řádek neprovede, aby byl zbytek textu česky)}
\FunctionTok{Sys.setlocale}\NormalTok{(}\StringTok{"LC\_TIME"}\NormalTok{, }\StringTok{"C"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Při načítání datumů je možné nastavit i~časovou zónu pomocí parametru \texttt{tz}. Jinak se automaticky vezme časová zóna z~vašeho operačního sytému (v~mém případě nyní ``CEST'', tj.~středoevropský letní čas).

Pokud máte dobrodružnější povahu a jednotlivé části datumu jsou zadané pomocí čísel dnů, měsíců a let, můžete použít pohodlnější funkce z~balíku \textbf{lubridate}. Těchto funkcí je celá řada a jmenují se na první pohled krypticky \texttt{ymd()}, \texttt{ydm()}, \texttt{mdy()}, \texttt{myd()}, \texttt{dmy()} a \texttt{dym()}. Jednotlivá písmena určují, v~jakém pořadí jsou uvedeny jednotlivé složky datumu: \texttt{y}~znamená rok, \texttt{m}~měsíc a \texttt{d}~den, takže funkce \texttt{ymd()} předpokládá, že v~datumu je nejdříve uveden rok, pak měsíc a nakonec den. Všechny tyto funkce jsou chytré, takže si poradí s~nejrůznějšími oddělovači. Pokud funkce na některém prvku vektoru selže, vydá varování. (Všimněte si, jak funkce naloží s~rokem zadaným jen dvěma číslicemi.)

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{dmy}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"1.6.1974"}\NormalTok{, }\StringTok{"17. 11. 1989"}\NormalTok{, }\StringTok{"1{-}1{-}2001"}\NormalTok{, }\StringTok{"1.3.99"}\NormalTok{, }\StringTok{"1.3.39"}\NormalTok{, }\StringTok{"bžů"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning: 1 failed to parse.
\end{verbatim}

\begin{verbatim}
## [1] "1974-06-01" "1989-11-17" "2001-01-01" "1999-03-01" "2039-03-01"
## [6] NA
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{ymd}\NormalTok{(}\DecValTok{20140531}\NormalTok{)  }\CommentTok{\# funguje i celé číslo, pokud je jednoznačné}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "2014-05-31"
\end{verbatim}

Datum je možné složit i~z~jednotlivých komponent pomocí funkce \texttt{make\_date()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{make\_date}\NormalTok{(}\AttributeTok{year =} \DecValTok{2011}\NormalTok{, }\AttributeTok{month =} \DecValTok{7}\NormalTok{, }\AttributeTok{day =} \DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "2011-07-05"
\end{verbatim}

K~zadání dne i~hodiny slouží funkce \texttt{as.POSIXct()}, která opět implicitně předpokládá datum a čas v~anglofonním formátu. Formát je opět možné změnit zadáním parametru \texttt{format}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.POSIXct}\NormalTok{(}\StringTok{"1974{-}06{-}01 7:30"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "1974-06-01 07:30:00 CET"
\end{verbatim}

Balík \textbf{lubridate} opět nabízí uživatelsky přívětivější (ale méně striktní, a~tedy bezpečné) funkce \texttt{ymd\_hms()}, \texttt{ymd\_hm()}, \texttt{ymd\_h()}, \texttt{dmy\_hms()}, \texttt{dmy\_hm()}, \texttt{dmy\_h()}, \texttt{mdy\_hms()}, \texttt{mdy\_hm()}, \texttt{mdy\_h()}, \texttt{ydm\_hms()}, \texttt{ydm\_hm()} a \texttt{ydm\_h()}, kde písmena \texttt{d}, \texttt{m} a \texttt{y} mají stejný význam jako výše a \texttt{h}~znamená hodiny, \texttt{m}~minuty a \texttt{s}~sekundy:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{ymd\_hm}\NormalTok{(}\StringTok{"1974{-}06{-}01 7:30"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "1974-06-01 07:30:00 UTC"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{dmy\_hm}\NormalTok{(}\StringTok{"1. 6. 1974 7.30"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "1974-06-01 07:30:00 UTC"
\end{verbatim}

I~datum a čas je možné složit z~jednotlivých komponent pomocí funkce

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{make\_datetime}\NormalTok{(}\AttributeTok{year =} \DecValTok{2017}\NormalTok{, }\AttributeTok{month =} \DecValTok{1}\SpecialCharTok{:}\DecValTok{12}\NormalTok{, }\AttributeTok{day =} \DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "2017-01-01 UTC" "2017-02-01 UTC" "2017-03-01 UTC" "2017-04-01 UTC"
##  [5] "2017-05-01 UTC" "2017-06-01 UTC" "2017-07-01 UTC" "2017-08-01 UTC"
##  [9] "2017-09-01 UTC" "2017-10-01 UTC" "2017-11-01 UTC" "2017-12-01 UTC"
\end{verbatim}

\hypertarget{jednotlivuxe9-komponenty-datumu-a-ux10dasu}{%
\subsection{Jednotlivé komponenty datumu a času}\label{jednotlivuxe9-komponenty-datumu-a-ux10dasu}}

Často je potřeba z~datumu nebo času získat příslušnou hodnotu dne, měsíce nebo hodiny. K~je možné použít funkce \texttt{weekdays()}, \texttt{months()}, \texttt{days()} a \texttt{quarters()} ze základního balíku. Funkce \texttt{weekdays()} a \texttt{months()} vrací jména dnů a měsíců v~\emph{locace} počítače; mohou vrátit i~zkrácenou verzi jména, pokud je parametr \texttt{abbreviate} nastaven na hodnotu \texttt{TRUE}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d }\OtherTok{\textless{}{-}} \FunctionTok{as.Date}\NormalTok{(}\StringTok{"2016{-}11{-}05"}\NormalTok{)}
\FunctionTok{weekdays}\NormalTok{(d)  }\CommentTok{\# den v týdnu}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Sobota"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{months}\NormalTok{(d)    }\CommentTok{\# měsíc v roce}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "listopadu"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{quarters}\NormalTok{(d)  }\CommentTok{\# čtvrtletí}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Q4"
\end{verbatim}

Balík \textbf{lubridate} opět definuje další funkce pro práci s~jednotlivými komponentami datumu a času: \texttt{year()} vrací rok, \texttt{month()} vrací měsíc, \texttt{mday()} vrací číslo dne v~měsíci, \texttt{yday()} číslo dne v~roce, \texttt{wday()} číslo dne v~týdnu, \texttt{hour()} hodinu, \texttt{minute()} minutu a \texttt{second()} sekundu. Funkce \texttt{month()} a \texttt{wday()} mají navíc parametry \texttt{labels} a \texttt{abbr}. Pokud je \texttt{label} nastaveno na hodnotu \texttt{TRUE}, pak funkce vrací místo čísla jméno. Pokud je navíc \texttt{abbr} nastaveno na \texttt{TRUE}, pak je jméno zkráceno. Tyto funkce však vracejí vždy anglická jména dnů a měsíců, navíc kódovaná jako faktor. Také prvním dnem týdne je neděle (s~číslem~1). Funkce \texttt{tz()} vrací časovou zónu.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{year}\NormalTok{(d)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2016
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{month}\NormalTok{(d)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 11
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{month}\NormalTok{(d, }\AttributeTok{label =} \ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] lis
## 12 Levels: led < úno < bře < dub < kvě < čen < čec < srp < zář < ... < pro
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{wday}\NormalTok{(d)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{wday}\NormalTok{(d, }\AttributeTok{label =} \ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] So
## Levels: Ne < Po < Út < St < Čt < Pá < So
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{tz}\NormalTok{(d)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "UTC"
\end{verbatim}

Tyto funkce z~balíku \textbf{lubridate} je možné použít i~k~úpravě datumu a času:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d }\OtherTok{\textless{}{-}} \FunctionTok{ymd}\NormalTok{(}\StringTok{"2000{-}01{-}01"}\NormalTok{)}
\FunctionTok{day}\NormalTok{(d) }\OtherTok{\textless{}{-}} \DecValTok{31}
\FunctionTok{month}\NormalTok{(d) }\OtherTok{\textless{}{-}} \DecValTok{12}
\NormalTok{d}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "2000-12-31"
\end{verbatim}

Pokud je potřeba upravit více prvků data naráz, je možné použít funkci \texttt{update()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{update}\NormalTok{(d, }\AttributeTok{year =} \DecValTok{1989}\NormalTok{, }\AttributeTok{month =} \DecValTok{11}\NormalTok{, }\AttributeTok{mday =} \DecValTok{17}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "1989-11-17"
\end{verbatim}

\hypertarget{operace-s-datem-a-ux10dasem}{%
\subsection{Operace s datem a časem}\label{operace-s-datem-a-ux10dasem}}

Pro třídy \emph{Date} a \emph{POSIXct} fungují některé aritmetické a logické operace, jako je sčítání, odečítání a diference, násobení, dělení a porovnávání:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d }\OtherTok{\textless{}{-}} \FunctionTok{as.Date}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"2016{-}01{-}10"}\NormalTok{, }\StringTok{"2016{-}03{-}11"}\NormalTok{))}
\NormalTok{d}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "2016-01-10" "2016-03-11"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d[}\DecValTok{2}\NormalTok{] }\SpecialCharTok{{-}}\NormalTok{ d[}\DecValTok{1}\NormalTok{]              }\CommentTok{\# kolik dnů je mezi druhým a prvním dnem ve vektoru?}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Time difference of 61 days
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{diff}\NormalTok{(d)                  }\CommentTok{\# funguje i funkce pro diferenci}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Time difference of 61 days
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as.numeric}\NormalTok{(d[}\DecValTok{2}\NormalTok{] }\SpecialCharTok{{-}}\NormalTok{ d[}\DecValTok{1}\NormalTok{])  }\CommentTok{\# převod na celé číslo}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 61
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d }\SpecialCharTok{\textgreater{}} \StringTok{"2016{-}02{-}05"}         \CommentTok{\# které dny ve vektoru jsou po 5. únoru 2016?}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE  TRUE
\end{verbatim}

Většina aritmetických operací však pracuje na rozdílech mezi dvěma datumy, což je proměnná třídy \emph{difftime}. Práce s~touto třídou není úplně intuitivní, protože datumy a čas jsou plné různých nepravidelností (počet dnů se v~jednotlivých měsících liší, přestupné roky mají více dnů a některé minuty mají 61~sekund). Proto se zde blíže podíváme jen na dvě operace: zjištění časové vzdálenosti dvou bodů a tvorbu vektoru datumů s~konstantním rozestupem.

Pokud nás zajímá časová vzdálenost mezi dvěma daty, obyčejná diference vypíše rozdíl v~automaticky zvolených jednotkách. Užitečnější proto může být funkce \texttt{difftime()}, která vrací vzdálenost mezi dvěma dny v~jednotkách zadaných uživatelem pomocí parametru \texttt{units}, který může nabývat hodnot \texttt{"auto"}, \texttt{"secs"}, \texttt{"mins"}, \texttt{"hours"}, \texttt{"days"} nebo \texttt{"weeks"}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{difftime}\NormalTok{(d[}\DecValTok{2}\NormalTok{], d[}\DecValTok{1}\NormalTok{], }\AttributeTok{units =} \StringTok{"weeks"}\NormalTok{) }
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Time difference of 8.714286 weeks
\end{verbatim}

Balík \textbf{lubridate} definuje velké množství dalších funkcí datumovou aritmetiku a práci s~časovými intervaly. Zde se jim však nebudeme věnovat. Zájemci se mohou podívat do \citet{WickhamRfDS}, kap.~13 dostupné na \url{http://r4ds.had.co.nz/dates-and-times.html}, na web balíku \textbf{lubridate} na \url{http://lubridate.tidyverse.org/} nebo do původního článku o~tomto balíku, \citet{GrolemundWickhamJSS2011}, který je dostupný ke stažení na stránkách časopisu i~balíku \textbf{lubridate}.

\hypertarget{tvorba-ekvidistantnuxedch-ux10dasovuxfdch-vektorux16f}{%
\subsection{Tvorba ekvidistantních časových vektorů}\label{tvorba-ekvidistantnuxedch-ux10dasovuxfdch-vektorux16f}}

Často potřebujeme vytvořit vektor s~datumy nebo časem s~ekvidistantním odstupem. V~některých speciálních případech to můžeme udělat pomocí funkcí pro práci s~jednotlivými složkami datumu. Řekněme například, že potřebujeme vektor datumů pro začátek každého měsíce v~roce. To uděláme snadno např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{d }\OtherTok{\textless{}{-}} \FunctionTok{ymd}\NormalTok{(}\StringTok{"2017{-}01{-}01"}\NormalTok{)}
\FunctionTok{month}\NormalTok{(d) }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{12}
\NormalTok{d}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "2017-01-01" "2017-02-01" "2017-03-01" "2017-04-01" "2017-05-01"
##  [6] "2017-06-01" "2017-07-01" "2017-08-01" "2017-09-01" "2017-10-01"
## [11] "2017-11-01" "2017-12-01"
\end{verbatim}

Vytvořit jiné vektory je však obtížnější. Například vektor posledních dnů v~měsíci takto jednoduše vytvořit nejde, protože různé měsíce mají různý počet dnů. Náš algoritmus také nevytvořil data s~ekvidistantním odstupem, a~to právě proto, že různé měsíce jsou různě dlouhé.

K~vytvoření vektorů se skutečně stejným rozestupem mezi jednotlivými daty je možné použít funkci \texttt{seq()}. Stejně jako v~případě číselných vektorů je možné nastavit počátek a konec období a počet hodnot, nebo počátek období a odstup mezi položkami. Ten se nastaví pomocí parametru \texttt{by}. Tento parametr může mít hodnotu ``day'', ``week'', ``month'', ``quarter'' nebo ``year'' případně násobenou celým číslem; ke jménu délky periody je také možné přidat koncové~``s''. Jednodenní odstup je pak ``day'', dvoudenní ``2days'' apod.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{seq}\NormalTok{(}\AttributeTok{from =} \FunctionTok{ymd}\NormalTok{(}\StringTok{"2015{-}1{-}1"}\NormalTok{), }\AttributeTok{to =} \FunctionTok{ymd}\NormalTok{(}\StringTok{"2015{-}12{-}31"}\NormalTok{), }\AttributeTok{length.out =} \DecValTok{15}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "2015-01-01" "2015-01-27" "2015-02-22" "2015-03-20" "2015-04-15"
##  [6] "2015-05-11" "2015-06-06" "2015-07-02" "2015-07-28" "2015-08-23"
## [11] "2015-09-18" "2015-10-14" "2015-11-09" "2015-12-05" "2015-12-31"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{seq}\NormalTok{(}\FunctionTok{ymd}\NormalTok{(}\StringTok{"2015{-}1{-}1"}\NormalTok{), }\AttributeTok{by =} \StringTok{"2 days"}\NormalTok{, }\AttributeTok{length.out =} \DecValTok{10}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "2015-01-01" "2015-01-03" "2015-01-05" "2015-01-07" "2015-01-09"
##  [6] "2015-01-11" "2015-01-13" "2015-01-15" "2015-01-17" "2015-01-19"
\end{verbatim}

Kromě toho je odstup možné nastavit i~na jakoukoli hodnotu třídy \emph{difftime}, kterou vrací funkce \texttt{difftime()}, nebo na kteroukoli jednotku, kterou funkce \texttt{difftime()} dokáže zpracovat. Před jednotku je možné přidat celé číslo jako násobek této jednotky:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{odstup }\OtherTok{\textless{}{-}} \FunctionTok{ymd}\NormalTok{(}\StringTok{"2017{-}06{-}05"}\NormalTok{) }\SpecialCharTok{{-}} \FunctionTok{ymd}\NormalTok{(}\StringTok{"2017{-}06{-}01"}\NormalTok{)  }\CommentTok{\# odstup 4 dny}
\FunctionTok{seq}\NormalTok{(}\FunctionTok{ymd}\NormalTok{(}\StringTok{"2017{-}06{-}01"}\NormalTok{), }\AttributeTok{by =}\NormalTok{ odstup, }\AttributeTok{length.out =} \DecValTok{6}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "2017-06-01" "2017-06-05" "2017-06-09" "2017-06-13" "2017-06-17"
## [6] "2017-06-21"
\end{verbatim}

\hypertarget{systuxe9movuxfd-ux10das}{%
\subsection{Systémový čas}\label{systuxe9movuxfd-ux10das}}

Aktuální (systémový) čas lze zjistit funkcí \texttt{Sys.time()}, která vrací objekt třídy \emph{POSIXct}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{Sys.time}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "2021-07-22 12:45:36 CEST"
\end{verbatim}

Balík \textbf{lubridate} navíc přidává funkce \texttt{today()}, která vrací dnešní datum jako objekt třídy \emph{Date}, a~\texttt{now()}, která vrací okamžité datum a čas jako objekt třídy \emph{POSIXct}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{today}\NormalTok{()  }\CommentTok{\# den, kdy byla tato kniha naposledy zkompilována}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "2021-07-22"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{now}\NormalTok{()  }\CommentTok{\# a nyní včetně času}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "2021-07-22 12:45:36 CEST"
\end{verbatim}

\hypertarget{ux159uxedduxedcuxed-struktury}{%
\chapter{Řídící struktury}\label{ux159uxedduxedcuxed-struktury}}

Zatím jsme předpokládali, že R provádí kód skriptu řádek po řádku. Někdy je však potřeba běh kódu různě modifikovat: některé řádky provést pouze, když je splněná určitá podmínka; jiné řádky provádět opakovaně; a~někdy vypsat varování nebo zastavit běh skriptu s~chybovým hlášením. Těmito problémy se budeme nyní zabývat.

V~této kapitole se naučíte

\begin{itemize}
\tightlist
\item
  větvit kód pomocí podmínek
\item
  opakovat kód pomocí cyklů
\item
  vypisovat varování a zastavit kód chybovým hlášením
\item
  že je možné chybová hlášení odchytit a vyřešit
\end{itemize}

\hypertarget{sec:if}{%
\section{Větvení kódu}\label{sec:if}}

Normálně R zpracovává skript tak, že vyhodnocuje řádek po řádku. Někdy to však nechceme. Některé řádky můžeme např.~chtít provést pouze v~případě, že je splněná nějaká podmínka. K~tomu v~R slouží podmínka~\texttt{if}. Jediným argumentem \texttt{if} uvedeným v~závorkách je podmínka, tj.~výraz, který se musí vyhodnotit na logický vektor délky~1. Pokud je tento logický výraz splněný (má hodnotu~\texttt{TRUE}), pak R vyhodnotí následující výraz. Pokud má logický výraz hodnotu~\texttt{FALSE}, pak R následující výraz přeskočí. Ukažme si to na příkladu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \DecValTok{1}
\NormalTok{y }\OtherTok{\textless{}{-}} \DecValTok{2}
\ControlFlowTok{if}\NormalTok{ (x }\SpecialCharTok{==} \DecValTok{1}\NormalTok{)}
    \FunctionTok{print}\NormalTok{(}\StringTok{"O.K.: x je jedna!"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "O.K.: x je jedna!"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\ControlFlowTok{if}\NormalTok{ (y }\SpecialCharTok{==} \DecValTok{1}\NormalTok{)}
    \FunctionTok{print}\NormalTok{(}\StringTok{"O.K.: y je jedna!"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

V~tomto příkladě se první podmínka vyhodnotila jako pravdivá (\texttt{x} má opravdu hodnotu~1), takže R provedlo následující výraz a vypsalo ``O.K.: x je jedna!''. Naproti tomu druhá podmínka se vyhodnotila jako nepravdivá, takže druhý tiskový řádek R přeskočilo a nic nevypsalo. Všimněte si také, že k~porovnání dvou hodnot se používá~\texttt{==}.

Podmínka \texttt{if} se v~R vztahuje vždy jen na jeden následující výraz. Pokud se má při splnění podmínky provést více než jeden řádek kódu, je třeba tyto řádky seskupit pomocí složených závorek (výrazy zabalené do složených závorek tvoří \emph{blok} kódu):

\begin{Shaded}
\begin{Highlighting}[]
\ControlFlowTok{if}\NormalTok{ (x }\SpecialCharTok{==} \DecValTok{1}\NormalTok{) \{}
\NormalTok{    a }\OtherTok{\textless{}{-}} \DecValTok{5}
    \FunctionTok{print}\NormalTok{(}\StringTok{"O.K.: x je jedna!"}\NormalTok{)}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "O.K.: x je jedna!"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{a}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 5
\end{verbatim}

Nyní při splnění podmínky R nejdříve vloží do proměnné \texttt{a} hodnotu~5, a~pak vypíše ``O.K.: x je jedna!''. Pokud by podmínka splněná nebyla, R~by přeskočila oba řádky uvedené ve složených závorkách.

Někdy chceme, aby se část kódu provedla, pokud podmínka platí, zatímco jiná část kódu, pokud podmínka neplatí. K~tomu slouží klauzule \texttt{else}. V~následujícím kódu se vypíše ``O.K.: y je jedna!'', pokud je \texttt{y} rovno jedné, a~``O.K.: y není jedna!'', pokud se \texttt{y} od jedné liší.

\begin{Shaded}
\begin{Highlighting}[]
\ControlFlowTok{if}\NormalTok{ (y }\SpecialCharTok{==} \DecValTok{1}\NormalTok{) \{}
    \FunctionTok{print}\NormalTok{(}\StringTok{"O.K.: y je jedna!"}\NormalTok{)}
\NormalTok{\} }\ControlFlowTok{else}\NormalTok{ \{}
    \FunctionTok{print}\NormalTok{(}\StringTok{"O.K.: y není jedna!"}\NormalTok{)}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "O.K.: y není jedna!"
\end{verbatim}

Pozor: \texttt{else} musí být na stejném řádku, jako končící složená závorka nebo kód, který se provádí při splnění podmínky.

Podmínky lze libovolně řetězit, jak ukazuje následující příklad. Nejdříve se porovná \texttt{x} s~jedničkou. Pokud se \texttt{x} rovná jedné, pak se vypíše ``jedna'' a kód pokračuje za poslední složenou závorkou. Pokud se \texttt{x} od jedničky liší, prozkoumá se, zda je větší než jedna. Pokud je, vypíše se ``větší'', pokud není, vypíše se ``menší''. (Pozor, tento kód nepočítá s~tím, že by \texttt{x} mohlo mít i~hodnotu \texttt{NA} nebo \texttt{NaN}~-- vyzkoušejte si to.)

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \DecValTok{1}
\ControlFlowTok{if}\NormalTok{ (x }\SpecialCharTok{==} \DecValTok{1}\NormalTok{) \{}
    \FunctionTok{print}\NormalTok{(}\StringTok{"jedna"}\NormalTok{)}
\NormalTok{\} }\ControlFlowTok{else} \ControlFlowTok{if}\NormalTok{ (x }\SpecialCharTok{\textgreater{}} \DecValTok{1}\NormalTok{) \{}
    \FunctionTok{print}\NormalTok{(}\StringTok{"větší"}\NormalTok{)}
\NormalTok{\} }\ControlFlowTok{else}\NormalTok{ \{}
    \FunctionTok{print}\NormalTok{(}\StringTok{"menší"}\NormalTok{)}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "jedna"
\end{verbatim}

Je také možné vnořit jednu podmínku do jiné, jak ukazuje následující příklad:

\begin{Shaded}
\begin{Highlighting}[]
\ControlFlowTok{if}\NormalTok{ (x }\SpecialCharTok{\textgreater{}} \DecValTok{0}\NormalTok{) \{}
    \ControlFlowTok{if}\NormalTok{ (x }\SpecialCharTok{\textgreater{}} \DecValTok{10}\NormalTok{) \{}
        \FunctionTok{print}\NormalTok{(}\StringTok{"x je opravdu velké kladné."}\NormalTok{)}
\NormalTok{    \} }\ControlFlowTok{else}\NormalTok{ \{}
        \FunctionTok{print}\NormalTok{(}\StringTok{"x je malé kladné"}\NormalTok{)}
\NormalTok{    \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "x je malé kladné"
\end{verbatim}

Podmínky byste však neměli zanořovat příliš, protože by váš kód byl nepřehledný. (Všimněte si také, jak jsou v~kódu odsazené řádky. R~to nijak nevyžaduje. Je to však velmi užitečná konvence, která výrazně zvyšuje čitelnost kódu.)

Vlastní podmínka je vždy logická hodnota, přesněji logický vektor délky~1, který má hodnotu buď \texttt{TRUE} nebo \texttt{FALSE}, tj.~ne \texttt{NA}. Pokud potřebujete složitější podmínku, musíte použít ``zkratující'' verze logických operátorů, viz oddíl~\ref{sec:data-types-log-oper}. Pokud se má nějaký kus kódu provést pouze v~případě, že platí \texttt{x} a zároveň \texttt{y} nebo \texttt{z}, zapíšeme to takto:

\begin{Shaded}
\begin{Highlighting}[]
\ControlFlowTok{if}\NormalTok{ (x }\SpecialCharTok{\&\&}\NormalTok{ (y }\SpecialCharTok{||}\NormalTok{ z)) \{}
\NormalTok{    ...}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Nápovědu k~\texttt{if} (a~dalším řídícím strukturám) získáte jedním z~následujících způsobů:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{?}\StringTok{\textasciigrave{}}\AttributeTok{if}\StringTok{\textasciigrave{}}
\FunctionTok{help}\NormalTok{(}\StringTok{"if"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\hypertarget{opakovuxe1nuxed-kuxf3du}{%
\section{Opakování kódu}\label{opakovuxe1nuxed-kuxf3du}}

V~některých situacích potřebujeme, aby se nějaký kus kódu provedl vícekrát. K~tomu slouží cykly. Existuje několik typů cyklů, které se liší podle toho, kolikrát se má daný kus kódu zopakovat.

\hypertarget{sec:for}{%
\subsection{Cyklus se známým počtem opakování}\label{sec:for}}

Nejjednodušší je cyklus \texttt{for}, který použijeme, když chceme nějaký kus kódu provést \(x\)-krát, kde \(x\) je libovolné číslo známé před započetím cyklu. Cykly se používají nejčastěji k~rekurzivním výpočtům. Řekněme např., že potřebujete nasimulovat data o~náhodné procházce. Počáteční hodnota \(y_1 = 0\), další hodnoty jsou konstruované rekurzivně jako \(y_t = y_{t-1} + \epsilon_t\) pro \(t>1\), kde \(\epsilon_t\) je náhodná chyba vygenerovaná ze standardizovaného normálního rozdělení. Vektor tisíce pozorování je pak možné nasimulovat např.~takto (výsledek ukazuje obrázek~\ref{fig:for-simul}):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{N }\OtherTok{\textless{}{-}} \DecValTok{1000}
\NormalTok{y }\OtherTok{\textless{}{-}} \FunctionTok{numeric}\NormalTok{(N)}
\NormalTok{y[}\DecValTok{1}\NormalTok{] }\OtherTok{\textless{}{-}} \DecValTok{0}  \CommentTok{\# zbytečné, ale pro přehlednost lepší}
\ControlFlowTok{for}\NormalTok{ (t }\ControlFlowTok{in} \DecValTok{2}\SpecialCharTok{:}\NormalTok{N)  }\CommentTok{\# vlastní cyklus}
\NormalTok{    y[t] }\OtherTok{\textless{}{-}}\NormalTok{ y[t }\SpecialCharTok{{-}} \DecValTok{1}\NormalTok{] }\SpecialCharTok{+} \FunctionTok{rnorm}\NormalTok{(}\DecValTok{1}\NormalTok{)  }\CommentTok{\# kód, který se opakuje 999x}
\FunctionTok{plot}\NormalTok{(y, }\AttributeTok{type =} \StringTok{"l"}\NormalTok{)  }\CommentTok{\# vykreslení výsledku}
\end{Highlighting}
\end{Shaded}

\begin{figure}
\centering
\includegraphics{control_structures_files/figure-latex/for-simul-1.pdf}
\caption{\label{fig:for-simul}Výsledek simulace náhodné procházky pomocí cyklu.}
\end{figure}

Náš kód funguje takto: Nejdříve ze všeho vytvoříme celý vektor~\texttt{y}. Sice bychom mohli začít vektorem délky~1 a postupně jej prodlužovat, to by však nutilo R neustále doalokovávat další paměť a výrazně by to zpomalilo výsledek. Proto je vždy lepší si dopředu předalokovat celou potřebnou paměť tím, že vytvoříme celé datové struktury ve velikosti, jakou bude mít výsledek výpočtu.

Vlastní cyklus začíná klíčovým slovem \texttt{for}. Proměnná~\texttt{t} je \emph{počítadlo} cyklu a postupně nabývá hodnot z~vektoru uvedeného za klíčovým slovem~\texttt{in}. Protože chceme, aby \texttt{t} postupně nabývalo hodnot~2 až 1~000, mohlo by se zdát jednodušší napsat \texttt{t\ in\ 2:1000}. To by však nebyl dobrý nápad. Nyní sice chceme simulovat právě tisíc pozorování, ale v~budoucnu se možná rozhodneme jinak. Bezpečnější tak určitě je napsat \texttt{t\ in\ 2:N}, protože pak můžeme počet pozorování změnit na jediném řádku, a~vše bude korektně fungovat.
Cyklus \texttt{for} proběhne v~našem případě tak, že \(N-1\)~krát spustí řádek \texttt{y{[}t{]}\ \textless{}-\ y{[}t\ -\ 1{]}\ +\ rnorm(1)}, přičemž počítadlo~\texttt{t} bude postupně nabývat hodnot~2, 3, 4 atd., až se naplní celý vektor~\texttt{y}. (Výsledek simulace záleží na generátoru pseudonáhodných čísel, takže bude pokaždé jiný.)

Stejně jako podmínka \texttt{if} i~cyklus \texttt{for} provádí vždy jen jeden výraz. Pokud chceme, aby provedl více výrazů, pak musíme tyto výrazy uzavřít do složených závorek, tj.~vytvořit z~nich blok, jak ukazuje následující příklad:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{N }\OtherTok{\textless{}{-}} \DecValTok{1000}
\NormalTok{y }\OtherTok{\textless{}{-}} \FunctionTok{numeric}\NormalTok{(N)}
\NormalTok{z }\OtherTok{\textless{}{-}} \FunctionTok{numeric}\NormalTok{(N)}
\ControlFlowTok{for}\NormalTok{ (t }\ControlFlowTok{in} \DecValTok{2}\SpecialCharTok{:}\DecValTok{1000}\NormalTok{) \{}
\NormalTok{    y[t] }\OtherTok{\textless{}{-}}\NormalTok{ y[t }\SpecialCharTok{{-}} \DecValTok{1}\NormalTok{] }\SpecialCharTok{+} \FunctionTok{rnorm}\NormalTok{(}\DecValTok{1}\NormalTok{)}
\NormalTok{    z[t] }\OtherTok{\textless{}{-}} \FunctionTok{sum}\NormalTok{(y[}\DecValTok{1}\SpecialCharTok{:}\NormalTok{t])}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Opět je vhodné kód výrazně odsadit, abychom zlepšili jeho čitelnost.

Někdy potřebujeme iterovat nad nějakým vektorem~\texttt{y}. Na první pohled by se mohlo zdát, že počítadlo by mělo nabývat hodnot \texttt{t\ in\ 1:lenght(y)}. To však není dobrý nápad. Někdy se totiž může stát, že vektor~\texttt{y} bude mít nulovou délku. Pak chceme, aby cyklus vůbec neproběhl. Pokud však počítadlo nastavíme výše uvedeným způsobem, cyklus překvapivě proběhne (a~pravděpodobně skončí chybou). Důvod je ten, že dvojtečka má v~cyklu svůj normální výraz konstruktoru vektorů. Pokud je \texttt{lenght(y)} rovno nule, pak má cyklus iterovat přes prvky vektoru \texttt{1:0}, což je vektor o~délce~2 a hodnotách \texttt{c(1,\ 0)}. Správně tedy musí být počítadlo nastavené pomocí funkce \texttt{seq\_along()} jako \texttt{t\ in\ seq\_along(y)}.

Iterovat nad prvky nějakého vektoru~\texttt{x} můžeme třemi různými způsoby: 1)~můžeme iterovat nad indexy prvků, jako jsme to dělali v~našem příkladu (použijeme např.~\texttt{for\ (k\ in\ seq\_along(x))}), 2)~můžeme iterovat přímo nad hodnotami daného vektoru (použijeme \texttt{for\ (k\ in\ x)}) nebo 3)~můžeme iterovat nad jmény prvků vektoru (použijeme \texttt{for\ (k\ in\ names(x))}). První způsob se používá nejčastěji, ale i další varianty jsou někdy užitečné.

Existují situace, kdy se bez cyklu \texttt{for} neobejdeme. V~R se však tento cyklus používá mnohem méně než v~jiných jazycích. Důvody jsou dva: Zaprvé, R~je vektorizovaný jazyk se spoustou vektorizovaných funkcí, takže mnoho operací, které je v~jiných jazycích nutné psát pomocí cyklu, v~R vyřeší vektorizace. Dokonce i~náš první příklad cyklu je vlastně zbytečný a simulaci je možné provést takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{N }\OtherTok{\textless{}{-}} \DecValTok{1000}
\NormalTok{e }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{0}\NormalTok{, }\FunctionTok{rnorm}\NormalTok{(N }\SpecialCharTok{{-}} \DecValTok{1}\NormalTok{))  }\CommentTok{\# simulace náhodné složky}
\NormalTok{y }\OtherTok{\textless{}{-}} \FunctionTok{cumsum}\NormalTok{(e)  }\CommentTok{\# kumulativní součet}
\end{Highlighting}
\end{Shaded}

Za druhé, pro iteraci nad vektory má R jiný velmi silný nástroj, a~to funkce typy \texttt{map()}, se kterými se seznámíte v~kapitole~\ref{kap:iterace-nad-vektory}.

Dokumentaci k~cyklu \texttt{for} najdete pomocí \texttt{help("for")}.

\hypertarget{cykly-s-neznuxe1muxfdm-poux10dtem-opakovuxe1nuxed}{%
\subsection{Cykly s neznámým počtem opakování}\label{cykly-s-neznuxe1muxfdm-poux10dtem-opakovuxe1nuxed}}

V~některých situacích nevíme, kolikrát bude potřeba kus kódu opakovat. Pro tyto účely slouží dva standardní typy cyklů: cyklus \texttt{while} opakuje kus kódu, dokud je splněná nějaká podmínka; naproti tomu cyklus \texttt{repeat} opakuje kus kódu donekonečna s~možností cyklus přerušit, pokud je nějaká podmínka splněná. Rozdíl mezi cykly spočívá v~tom, kdy se podmínka vyhodnotí: v~cyklu \texttt{while} se podmínka vyhodnocuje na začátku, takže cyklus nemusí proběhnout ani jednou; naproti tomu v~cyklu \texttt{repeat} se podmínka vyhodnocuje v~principu až na konci, takže cyklus vždy proběhne aspoň jednou. Tyto cykly se při datové analýze nepoužívají příliš často. Zato jsou velmi užitečné v~simulacích, optimalizacích a podobných úlohách. Zde se podíváme pouze na jednodušší a častěji používaný cyklus \texttt{while}. Více se o~obou cyklech můžete dozvědět z~dokumentace (\texttt{help("while")}).

Použití cyklu \texttt{while} si ukážeme na následujícím příkladu: Předpokládejme, že chceme zjistit, kolikrát musíme hodit kostkou, než padne šestka. To můžeme provést např.~následujícím kódem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{pocet }\OtherTok{\textless{}{-}} \DecValTok{0}
\NormalTok{kostka }\OtherTok{\textless{}{-}} \DecValTok{0}
\ControlFlowTok{while}\NormalTok{ (kostka }\SpecialCharTok{!=} \DecValTok{6}\NormalTok{) \{}
\NormalTok{    pocet }\OtherTok{\textless{}{-}}\NormalTok{ pocet }\SpecialCharTok{+} \DecValTok{1}
\NormalTok{    kostka }\OtherTok{\textless{}{-}} \FunctionTok{sample}\NormalTok{(}\DecValTok{6}\NormalTok{, }\AttributeTok{size =} \DecValTok{1}\NormalTok{)}
\NormalTok{\}}
\FunctionTok{print}\NormalTok{(pocet)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4
\end{verbatim}

Skript funguje takto: nejdříve si vytvoříme proměnnou \texttt{pocet}, do které budeme shromažďovat uplynulý počet hodů. Dále vytvoříme proměnnou \texttt{kostka}, do které uložíme hod kostkou. Vlastní cyklus začíná klíčovým slovem \texttt{while}. V~závorce za ním je podmínka, tj.~výraz, který se musí vyhodnotit na logický vektor délky~1. Pokud je podmínka splněná (logický výraz se vyhodnotí na~\texttt{TRUE}), vyhodnotí se výraz, který následuje. Protože chceme vyhodnotit dva výrazy, musíme je pomocí složených závorek uzavřít do bloku.

Při prvním průchodu cyklu je \texttt{kostka} rovna nule, proto se cyklus provede: počítadlo \texttt{pocet} se zvýší o~1 a ``hodíme kostkou'' (funkce \texttt{sample()} v~našem případě vygeneruje náhodné celé číslo od~1 do~6). Pokud ``padlo'' jiné číslo než~6, cyklus proběhne znovu (počítadlo se zvýší o~další~1 a znovu se hodí kostkou). To se opakuje, dokud je podmínka splněná (tj.~\texttt{kostka} je různá od~6). Jakmile se \texttt{kostka} rovná šesti, cyklus už neproběhne a R~přejde na vypsání hodnoty \texttt{pocet}. (Výsledek simulace záleží na generátoru pseudonáhodných čísel, takže bude pokaždé jiný.)

Podívejme se na jiný stylizovaný příklad. Řekněme, že chceme zjistit, pro jaký vstup z~určitého intervalu nabývá nějaká funkce určité hodnoty. Aby byla úloha jednoduchá, budeme předpokládat, že funkce je monotónně rostoucí. V~takovém případě můžeme použít primitivní algoritmus půlení intervalů. Jako funkci budeme v~našem příkladu pro jednoduchost uvažovat přirozený logaritmus a budeme hledat takovou hodnotu~\(x\) z~intervalu \([0, 10]\), pro kterou je \(log(x) = 1\):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{hodnota }\OtherTok{\textless{}{-}} \DecValTok{1}
\NormalTok{funkce }\OtherTok{\textless{}{-}}\NormalTok{ log}
\NormalTok{dint }\OtherTok{\textless{}{-}} \DecValTok{0}
\NormalTok{hint }\OtherTok{\textless{}{-}} \DecValTok{10}
\NormalTok{tolerance }\OtherTok{\textless{}{-}} \FloatTok{1e{-}10}
\NormalTok{chyba }\OtherTok{\textless{}{-}} \ConstantTok{Inf}
\ControlFlowTok{while}\NormalTok{ (}\FunctionTok{abs}\NormalTok{(chyba) }\SpecialCharTok{\textgreater{}}\NormalTok{ tolerance) \{}
\NormalTok{    vysledek }\OtherTok{\textless{}{-}}\NormalTok{ (dint }\SpecialCharTok{+}\NormalTok{ hint) }\SpecialCharTok{/} \DecValTok{2}
\NormalTok{    pokusna\_hodnota }\OtherTok{\textless{}{-}} \FunctionTok{funkce}\NormalTok{(vysledek)}
    \ControlFlowTok{if}\NormalTok{ (pokusna\_hodnota }\SpecialCharTok{\textless{}}\NormalTok{ hodnota)}
\NormalTok{        dint }\OtherTok{\textless{}{-}}\NormalTok{ vysledek}
    \ControlFlowTok{if}\NormalTok{ (pokusna\_hodnota }\SpecialCharTok{\textgreater{}}\NormalTok{ hodnota)}
\NormalTok{        hint }\OtherTok{\textless{}{-}}\NormalTok{ vysledek}
\NormalTok{    chyba }\OtherTok{\textless{}{-}}\NormalTok{ hodnota }\SpecialCharTok{{-}}\NormalTok{ pokusna\_hodnota}
\NormalTok{\}}
\NormalTok{vysledek}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2.718282
\end{verbatim}

Nejprve jsme zadali hledanou hodnotu (\texttt{hodnota}), použitou funkci (\texttt{funkce}), horní a dolní mez prohledávaného intervalu (\texttt{dint} a \texttt{hint}) a toleranci (\texttt{tolerance}), se kterou má algoritmus pracovat. Zadali jsme i~počáteční velikost chyby (\texttt{chyba}). Vlastní výpočet funguje takto: pokud je absolutní hodnota chyby větší než zadaná tolerance, provedeme úpravu mezí, a~to tak, že 1.~najdeme hodnotu uprostřed intervalu, 2.~vyhodnotíme hodnotu funkce v~tomto bodě, 3.~pokud je výsledek nižší než požadovaná hodnota, posuneme dolní mez na úroveň středu intervalu; v~opačném případě takto posuneme horní mez, 4.~spočítáme velikost chyby. Cyklus upravuje meze tak dlouho, dokud není chyba menší než zadaná tolerance. Nakonec vypíšeme hledanou hodnotu, která zůstala v~proměnné \texttt{vysledek}. Výsledek si můžeme snadno ověřit ``zkouškou''; můžeme se také podívat, že chyba je opravdu menší než zadaná tolerance (protože pro přirozený logaritmus máme k~dispozici inverzní funkci):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{log}\NormalTok{(vysledek)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{exp}\NormalTok{(}\DecValTok{1}\NormalTok{) }\SpecialCharTok{{-}}\NormalTok{ vysledek}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] -1.064779e-10
\end{verbatim}

Algoritmus je velmi rychlý, ale samozřejmě není příliš obecný: funguje jen pro monotonně rostoucí funkce. (R~má naštěstí celou řadu funkcí, které dokážou numericky optimalizovat zadanou funkci.)

\hypertarget{zastavenuxed-kuxf3du-a-varovuxe1nuxed}{%
\section{Zastavení kódu a varování}\label{zastavenuxed-kuxf3du-a-varovuxe1nuxed}}

Někdy je potřeba výpočet zastavit a vydat chybovou hlášku. Typicky to chcete udělat, když váš kód dostal špatný vstup. Řekněme např., že stahujete data z~nějakého serveru a víte, že některá proměnná může mít jen určité úrovně. Převedete ji tedy na faktor a zkontrolujete, že žádná hodnota ve faktoru není \texttt{NA}, což by signalizovalo, že server změnil kódování úrovní. Pokud tedy ve vektoru najdete \texttt{NA}, chcete kód ukončit chybou, abyste zjistili, že musíte situaci řešit.

K~zastavení běhu skriptu slouží funkce \texttt{stop()}: zastaví běh skriptu a jako chybovou hlášku vypíše svůj argument. Následující kód zastaví běh skriptu a vypíše chybovou hlášku, pokud \texttt{v} obsahuje řetězec:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v }\OtherTok{\textless{}{-}} \StringTok{"ahoj"}
\ControlFlowTok{if}\NormalTok{ (}\FunctionTok{is.character}\NormalTok{(v))}
    \FunctionTok{stop}\NormalTok{(}\StringTok{"v je řetězec!"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error in eval(expr, envir, enclos): v je řetězec!
\end{verbatim}

Jednodušší variantou předchozího kódu je použití funkce \texttt{stopifnot()}. Ta zastaví kód, pokud se zadaný výraz nevyhodnotí na~\texttt{TRUE}. V~tom případě se vypíše jako chybová hláška, že daný výraz není~\texttt{TRUE}. Předchozí podmínku pak můžeme zapsat přibližně takto (všimněte si znaku~\texttt{!}, který neguje zadaný výraz):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{stopifnot}\NormalTok{(}\SpecialCharTok{!}\FunctionTok{is.character}\NormalTok{(v))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: !is.character(v) is not TRUE
\end{verbatim}

Někdy problém není tak velký, že bychom chtěli běh skriptu zastavit. Chceme však upozornit uživatele (nejčastěji sami sebe), že někde nastal nějaký problém. R~umí posílat dva typy signálů: zprávy (messages) a varování (warnings).
Zprávy je možné do konzoly vypsat pomocí funkce \texttt{message()}, varování pomocí funkce \texttt{warning()}. Obě tyto funkce vypíší do konzoly svůj argument:

\begin{Shaded}
\begin{Highlighting}[]
\ControlFlowTok{if}\NormalTok{ (}\SpecialCharTok{!}\FunctionTok{is.list}\NormalTok{(v))}
    \FunctionTok{warning}\NormalTok{(}\StringTok{"Pozor: v není seznam!"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning: Pozor: v není seznam!
\end{verbatim}

Do konzoly je samozřejmě možné vypisovat i~pomocí funkcí \texttt{print()}, \texttt{cat()} apod. Zprávy o~běhu kódu však vypisujte raději pomocí \texttt{message()} a \texttt{warning()}: v~RStudiu jsou barevně odlišené a je možné je snadno potlačit pomocí funkcí \texttt{suppressMessages()} a \texttt{suppressWarnings()}, pokud nejsou žádoucí, což v~případě \texttt{print()} a spol. nejde.

\hypertarget{odchycenuxed-chyb}{%
\section{Odchycení chyb}\label{odchycenuxed-chyb}}

Někdy potřebujeme napsat skript, který musí být rezistentní vůči chybám~-- jeho běh nesmí skončit ani v~případě, že chyba nastane. Typickým případem je situace, kdy stahujeme nějaká data ze sítě, např.~z~API Googlu, ale naše připojení k~internetu je poruchové. Pak funkce, která stahuje data skončí chybou. My však nechceme, aby skript zhavaroval. Místo toho chceme chybu odchytit a nějak zpracovat, např.~chvíli počkat, a~pak se pokusit stáhnout data znovu.

Stejně jako většina pokročilých programovacích jazyků, i~R má nástroje pro ``zpracování výjimek''. V~R je zastupují funkce \texttt{try()} a \texttt{tryCatch()}. Pokud je budete někdy potřebovat použít, podívejte se do jejich dokumentace.

\hypertarget{aplikace-simulace-hry-hadi-a-ux17eebux159uxedky}{%
\section{Aplikace: simulace hry Hadi a žebříky}\label{aplikace-simulace-hry-hadi-a-ux17eebux159uxedky}}

Existuje hra, kterou malé děti milují a jejich rodiče nenávidí: \emph{Hadi a žebříky} (v~originále \emph{Snakes and ladders}). Pravidla hry jsou jednoduchá: každý hráč má právě jednu figurku, kterou postaví na první pole hry. Hráči se pak po řadě střídají v~tom, kdo hází kostkou. Hráč, který právě hodil kostkou, posune svoji figurku o~tolik polí, kolik mu na kostce padlo. Vítězem je ten hráč, který se jako první dostane na poslední, 100.~pole. Hra je ozvláštněna speciálními poli: kdo šlápne na pole paty žebříku, ten se posune o~daný počet polí dopředu (``vyjede po žebříku''), kdo však šlápne na hlavu hadovi, vrátí se o~daný počet polí zpět (``sjede po hadovi''). Herní plán ukazuje obrázek~\ref{fig:ctrl-snakes-and-ladders}

\begin{figure}
\includegraphics[width=4in]{figs/control_structures/snakes-and-ladders} \caption{Koberec s deskovou hrou Snakes and ladders nabízený serverem *Activities for elderly people with dementia and Alzheimer's*, http://www.activitiestoshare.co.uk/snakes-and-ladders-floor-mat.}\label{fig:ctrl-snakes-and-ladders}
\end{figure}

Už asi tušíte, proč děti hru milují: vše je dáno jen náhodou, jejíž zvraty jsou kvůli umístění žebříků a hadů často veliké, takže poslední hráč se může pár tahy vyšvihnout do začátku pelotonu, zatímco dosud první hráč může snadno spadnout na konec. Navíc hra trvá opravdu dlouho. Asi je také jasné, proč rodiče hru naprosto nenávidí: vlastně se nejedná o~hru! Vše je dáno náhodou, chybí jakákoli interakce mezi hráči a hra může trvat neskutečně dlouho (nekonečně dlouho, zdá se znuděnému rodiči). Člověče nezlob se je proti této hře posledním výkřikem moderních strategických her.

Naším cílem bude nasimulovat deset tisíc krát průběh hry a zjistit, jaké je rozdělení počtu hodů potřebných k~ukončení hry. Pro jednoduchost si problém zjednodušíme tak, že budeme uvažovat jen jednoho hráče. Dále budeme předpokládat, že k~vítězství ve hře není potřeba se přesně trefit na 100.~pole, ale že stačí se dostat na ně nebo za ně.
Následně použijeme data ze simulace s~jedním hráčem k~odhadu počtu tahů, které potřebují k~ukončení hry dva nebo tři hráči. Pro jednoduchost budeme předpokládat, že hra končí ve chvíli, kdy jeden z~hráčů vyhrál, tj.~že se nedohrává až do konce. (Nápověda: hráči nijak neinteragují.)

Začneme tím, že si první úkol rozebereme. Budeme potřebovat dvě proměnné: Zaprvé, proměnnou \texttt{panacek}, ve které budeme mít uložené pole, na kterém panáček stojí. Na začátku bude mít tato proměnná hodnotu~1.
Zadruhé, budeme potřebovat proměnnou \texttt{hody}, kam si budeme zaznamenávat, kolik hodů už proběhlo. Počáteční hodnota této proměnné je samozřejmě~0.

Každá jednotlivá hra bude spočívat v~opakování tří kroků: 1.~Hodíme kostkou a posuneme panáčka o~tolik kroků, o~kolik bude potřeba. 2.~Až se panáček posune, zkontrolujeme, na jakém poli figurka stojí: pokud je to žebřík, posuneme jej nahoru, pokud had, posuneme jej dolů, jinak jej necháme na místě. 3.~Zvýšíme hodnotu počítadla hodů o~1. Tyto tři kroky budeme opakovat tak dlouho, dokud panáček nebude stát na poli 100 nebo za ním. Na konci si zapamatujeme, kolik hodů bylo k~ukončení hry potřeba. Kód pro jednu hru tak bude vypadat nějak takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{    panacek }\OtherTok{\textless{}{-}}\NormalTok{ 1L}
\NormalTok{    hod }\OtherTok{\textless{}{-}}\NormalTok{ 0L}
    \ControlFlowTok{while}\NormalTok{ (panacek }\SpecialCharTok{\textless{}}\NormalTok{ 100L) \{}
\NormalTok{        hod }\OtherTok{\textless{}{-}}\NormalTok{ hod }\SpecialCharTok{+}\NormalTok{ 1L}
\NormalTok{        panacek }\OtherTok{\textless{}{-}}\NormalTok{ panacek }\SpecialCharTok{+} \FunctionTok{sample}\NormalTok{(}\DecValTok{6}\NormalTok{, }\AttributeTok{size =} \DecValTok{1}\NormalTok{)}
\NormalTok{        panacek }\OtherTok{\textless{}{-}}\NormalTok{ pole[panacek]}
\NormalTok{    \}}
\end{Highlighting}
\end{Shaded}

Funkce \texttt{sample(6,\ size\ =\ 1)} na předposledním řádku cyklu vrátí náhodné číslo z~oboru 1,~2,~\ldots,~6 (tj.~simuluje hod kostkou). Otázkou je, jak vyřešíme hady a žebříky. To je možné udělat celou řadů způsobů. Můžeme např.~pro každého hada a žebřík napsat podmínku typu

\begin{Shaded}
\begin{Highlighting}[]
\ControlFlowTok{if}\NormalTok{ (panacek }\SpecialCharTok{==} \DecValTok{4}\NormalTok{)}
\NormalTok{    panacek }\OtherTok{\textless{}{-}} \DecValTok{14}
\end{Highlighting}
\end{Shaded}

která posune panáčka ze 4.~na 14.~pole (1.~žebřík). Já preferuji poněkud globálnější přístup, který ukazuje poslední řádek cyklu: vytvoříme vektor \texttt{pole}, který pro každé herní políčko řekne, kam se má panáček posunout. Pokud dané pole neobsahuje ani hada, ani žebřík, bude obsahovat svůj vlastní index. Proměnnou pole vytvoříme např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# inicializace hracího pole}
\NormalTok{pole }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{105}
\CommentTok{\# {-}{-} žebříky}
\NormalTok{pole[}\DecValTok{4}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 14L}
\NormalTok{pole[}\DecValTok{9}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 31L}
\NormalTok{pole[}\DecValTok{20}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 38L}
\NormalTok{pole[}\DecValTok{28}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 84L}
\NormalTok{pole[}\DecValTok{40}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 59L}
\NormalTok{pole[}\DecValTok{63}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 81L}
\NormalTok{pole[}\DecValTok{71}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 91L}
\CommentTok{\# {-}{-} hadi}
\NormalTok{pole[}\DecValTok{17}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 7L}
\NormalTok{pole[}\DecValTok{54}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 34L}
\NormalTok{pole[}\DecValTok{62}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 18L}
\NormalTok{pole[}\DecValTok{64}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 60L}
\NormalTok{pole[}\DecValTok{87}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 24L}
\NormalTok{pole[}\DecValTok{93}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 73L}
\NormalTok{pole[}\DecValTok{95}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 75L}
\NormalTok{pole[}\DecValTok{98}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 78L}
\end{Highlighting}
\end{Shaded}

Nejdříve inicializujeme \texttt{pole} tak, aby platilo \texttt{pole{[}i{]}\ =\ i}, tj.~aby hráč, který na toto pole šlápne, na něm i~zůstal. Pak přidáme žebříky a hady. Všimněte si, že pole nemá 100~prvků, ale~105. To je proto, že panáček se může díky hodu kostkou dostat za 100.~\texttt{pole}. Pokud bychom je neinicializovali, skript by skončil chybou. (Náš přístup k~poli je poněkud nedbalý~-- pokud by se hrací pole zvětšilo, rostly by nároky na paměť počítače. Hra \emph{Hadi a žebříky} se však, doufejme, nikdy nezvětší.)

Nyní tedy umíme zahrát jednu hru. Zbývá nám ji ještě deset tisíc krát zopakovat. To provedeme takto:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# počet simulací}
\NormalTok{N }\OtherTok{\textless{}{-}} \FloatTok{1e4}

\CommentTok{\# ... sem se vloží inicializace hracího pole...}

\CommentTok{\# alokace vektoru výsledků}
\NormalTok{vysledek }\OtherTok{\textless{}{-}} \FunctionTok{rep}\NormalTok{(}\ConstantTok{NA}\NormalTok{, N)}

\CommentTok{\# vlastní simulace}
\ControlFlowTok{for}\NormalTok{ (k }\ControlFlowTok{in} \FunctionTok{seq\_len}\NormalTok{(N)) \{}
    \CommentTok{\# ... sem se vloží kód pro jednu hru}
\NormalTok{    vysledek[k] }\OtherTok{\textless{}{-}}\NormalTok{ hod}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Nyní nám stačí celý kód spustit a vypsat popisné statistiky pomocí funkce \texttt{summary()} a případně vykreslit histogram rozdělení počtu hodů pomocí funkce \texttt{hist()} (v~kapitole \ref{kap:ggplot2} se naučíte kreslit hezčí grafy). Celý kód tedy vypadá takto:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# počet simulací}
\NormalTok{N }\OtherTok{\textless{}{-}} \FloatTok{1e4}

\CommentTok{\# inicializace hracího pole}
\NormalTok{pole }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{105}
\CommentTok{\# {-}{-} žebříky}
\NormalTok{pole[}\DecValTok{4}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 14L}
\NormalTok{pole[}\DecValTok{9}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 31L}
\NormalTok{pole[}\DecValTok{20}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 38L}
\NormalTok{pole[}\DecValTok{28}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 84L}
\NormalTok{pole[}\DecValTok{40}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 59L}
\NormalTok{pole[}\DecValTok{63}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 81L}
\NormalTok{pole[}\DecValTok{71}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 91L}
\CommentTok{\# {-}{-} hadi}
\NormalTok{pole[}\DecValTok{17}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 7L}
\NormalTok{pole[}\DecValTok{54}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 34L}
\NormalTok{pole[}\DecValTok{62}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 18L}
\NormalTok{pole[}\DecValTok{64}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 60L}
\NormalTok{pole[}\DecValTok{87}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 24L}
\NormalTok{pole[}\DecValTok{93}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 73L}
\NormalTok{pole[}\DecValTok{95}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 75L}
\NormalTok{pole[}\DecValTok{98}\NormalTok{] }\OtherTok{\textless{}{-}}\NormalTok{ 78L}

\CommentTok{\# alokace vektoru výsledků}
\NormalTok{vysledek }\OtherTok{\textless{}{-}} \FunctionTok{rep}\NormalTok{(}\ConstantTok{NA}\NormalTok{, N)}

\CommentTok{\# vlastní simulace}
\ControlFlowTok{for}\NormalTok{ (k }\ControlFlowTok{in} \FunctionTok{seq\_len}\NormalTok{(N)) \{}
\NormalTok{    panacek }\OtherTok{\textless{}{-}}\NormalTok{ 1L}
\NormalTok{    hod }\OtherTok{\textless{}{-}}\NormalTok{ 0L}
    \ControlFlowTok{while}\NormalTok{ (panacek }\SpecialCharTok{\textless{}}\NormalTok{ 100L) \{}
\NormalTok{        hod }\OtherTok{\textless{}{-}}\NormalTok{ hod }\SpecialCharTok{+}\NormalTok{ 1L}
\NormalTok{        panacek }\OtherTok{\textless{}{-}}\NormalTok{ panacek }\SpecialCharTok{+} \FunctionTok{sample}\NormalTok{(}\DecValTok{6}\NormalTok{, }\AttributeTok{size =} \DecValTok{1}\NormalTok{)}
\NormalTok{        panacek }\OtherTok{\textless{}{-}}\NormalTok{ pole[panacek]}
\NormalTok{    \}}
\NormalTok{    vysledek[k] }\OtherTok{\textless{}{-}}\NormalTok{ hod}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# shrnutí výsledků}
\FunctionTok{summary}\NormalTok{(vysledek)}
\FunctionTok{hist}\NormalTok{(vysledek)}
\end{Highlighting}
\end{Shaded}

Výsledky simulace ukazuje tabulka \ref{tab:snakes-and-ladders1t}, rozdělení počtu hodů potřebných k~ukončení hry ukazuje obrázek~\ref{fig:snakes-and-ladders1f}. Průměrný počet hodů, potřebný k~dokončení při v~jednom hráči, je 48.0785; ve čtvrtině her však nebude stačit ani 61 hodů.



\begin{table}

\caption{\label{tab:snakes-and-ladders1t}Souhrnné statistiky počtu hodů potřebných k~ukončení hry \emph{Hadi a žebříky}, pokud hraje jeden hráč.}
\centering
\begin{tabular}[t]{r|r|r|r|r|r}
\hline
Min. & 1st Qu. & Median & Mean & 3rd Qu. & Max.\\
\hline
7 & 25 & 39 & 48.0785 & 61 & 365\\
\hline
\end{tabular}
\end{table}

\begin{figure}
\centering
\includegraphics{control_structures_files/figure-latex/snakes-and-ladders1f-1.pdf}
\caption{\label{fig:snakes-and-ladders1f}Rozdělení počtu hodů potřebných k ukončení hry \emph{Hadi a žebříky}, pokud hraje jeden hráč.}
\end{figure}

Naším druhým úkolem je zjistit, kolik hodů kostkou by bylo potřeba, kdyby hru hrálo \(M > 1\) hráčů. Na první pohled by se mohlo zdát, že potřebujeme celou naši simulaci přepsat tak, aby v~rámci každé dílčí hry hrálo \(M\)~hráčů. To však vůbec není potřeba, a~to díky tomu, že hráči ve hře nijak neinteragují. Pokud tedy hrají tři hráči, je to stejné, jako by nezávisle na sobě hráli tři hráči. Hra skončí, když kterýkoli z~nich dojde na 100.~políčko. Kolik hodů k~tomu potřebuje, to máme uložené v~proměnné \texttt{vysledek}. Přibližně správný odhad tedy můžeme získat tak, že z~vektoru výsledek náhodně vybereme tři hodnoty (s~opakováním) a z~nich vezmeme nejmenší číslo (stanovili jsme si, že hra končí, když vyhrál první hráč). Tak zjistíme, kolikrát by musel hodit vítězný hráč. Jeho počet hodů musíme samozřejmě vynásobit počtem hráčů, protože ve skutečnosti každý hráč musel hodit tolikrát.

Pokud jsme estéti, můžeme ještě provést jistou korekci pro posledního hráče. Řekněme, že vítězný hráč hodil právě \(L\)-krát. Pokud hrají tři hráči, pak máme tři možnosti: 1)~Vítězný hráč začínal hru; pak je celkový počet hodů \((L - 1) \times 3 + 1\). 2)~Vítězný hráč házel jako druhý; pak je celkový počet hodů \((L - 1) \times 3 + 2\). A~konečně 3)~vítězný hráč házel jako poslední; pak je celkový počet hodů \(3L\). Každá z~těchto možností se stala právě s~pravděpodobností~\(1/3\). Pokud tedy hrají tři hráči, musíme od jednoduchého výsledku získaného jako trojnásobek počtu hodů vítězného hráče odečíst s~pravděpodobností~\(1/3\) dvojku, s~pravděpodobností~\(1/3\) jedničku a s~pravděpodobností~\(1/3\) nulu. Obecně musíme odečíst \((M - 1) / 2\).

Tímto postupem zjistíme, jak dlouho by hrálo \(M\)~hráčů v~jedné konkrétní hře. Výsledkem je tedy opět náhodné číslo. Simulaci opět potřebujeme zopakovat (řekněme 10~000~krát), abychom dostali rozdělení počtu hodů.

Celou simulaci provedeme snadno takto:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# počet hráčů}
\NormalTok{hracu }\OtherTok{\textless{}{-}} \DecValTok{3}

\CommentTok{\# alokace vektorů výsledků}
\NormalTok{vysledek2 }\OtherTok{\textless{}{-}} \FunctionTok{rep}\NormalTok{(}\ConstantTok{NA}\NormalTok{, N)}

\CommentTok{\# korekce počtu tahů (hráč, který hru ukončil nemusel hrát jako poslední)}
\NormalTok{korekce }\OtherTok{\textless{}{-}}\NormalTok{ (hracu }\SpecialCharTok{{-}} \DecValTok{1}\NormalTok{) }\SpecialCharTok{/} \DecValTok{2}

\CommentTok{\# vlastní simulace (bootstrap)}
\ControlFlowTok{for}\NormalTok{ (k }\ControlFlowTok{in} \FunctionTok{seq\_len}\NormalTok{(N)) \{}
\NormalTok{    vyber }\OtherTok{\textless{}{-}} \FunctionTok{sample}\NormalTok{(N, }\AttributeTok{size =}\NormalTok{ hracu, }\AttributeTok{replace =} \ConstantTok{TRUE}\NormalTok{)}
\NormalTok{    vysledek2[k] }\OtherTok{\textless{}{-}}\NormalTok{ hracu }\SpecialCharTok{*} \FunctionTok{min}\NormalTok{(vysledek[vyber]) }\SpecialCharTok{{-}}\NormalTok{ korekce}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Nejdříve do proměnné \texttt{hracu} uložíme počet hráčů, v~našem případě~3. Následně si předalokujeme vektor pro uložení výsledků simulace a spočítáme správnou korekci. Vlastní simulaci zopakujeme~\(N\)-krát (10~000~krát). Při každé jednotlivé simulaci vybereme pomocí funkce \texttt{sample()} tři náhodná čísla z~rozsahu~\(1, 2, \ldots, N\) s~opakováním. Tato čísla použijeme jako indexy k~výběru tří náhodných délek hry z~vektoru \texttt{vysledek} a s~jejich pomocí spočítáme střední dobu délky hry tří hráčů. Nakonec se podíváme na souhrnné statistiky pomocí funkce \texttt{summary()} a na histogram pomocí funkce~\texttt{hist()}.

Tabulka \ref{tab:snakes-and-ladders2t} ukazuje základní statistiku pro tři hráče. Průměrný počet nutných hodů při třech hráčích vzrostl z~48.0785 na 75.4427; ve čtvrtině her však nebude stačit ani 92 hodů. Obrázek~\ref{fig:snakes-and-ladders2f} ukazuje srovnání distribuce počtu hodů při jednom a při třech hráčích. Takové obrázky se naučíte kreslit v~kapitole~\ref{kap:ggplot2}.



\begin{table}

\caption{\label{tab:snakes-and-ladders2t}Souhrnné statistiky počtu hodů potřebných k~ukončení hry \emph{Hadi a žebříky}, pokud hrají tři hráči.}
\centering
\begin{tabular}[t]{r|r|r|r|r|r}
\hline
Min. & 1st Qu. & Median & Mean & 3rd Qu. & Max.\\
\hline
20 & 50 & 68 & 75.4427 & 92 & 347\\
\hline
\end{tabular}
\end{table}

\begin{figure}
\centering
\includegraphics{control_structures_files/figure-latex/snakes-and-ladders2f-1.pdf}
\caption{\label{fig:snakes-and-ladders2f}Rozdělení počtu hodů potřebných k ukončení hry \emph{Hadi a žebříky}, pokud hrají tři hráči.}
\end{figure}

Náš odhad distribuce počtu hodů nebude při opakování 10~000~krát úplně přesný a při každém spuštění vrátí poněkud odlišné výsledky. Zvýšení přesnosti můžete dosáhnout zvýšením počtu simulací, např.~na milion. Náš kód je možné ještě zobecnit a doladit tím, že je přepíšeme pomocí funkcí (viz kapitola~\ref{kap:funkce}) a funkce~\texttt{map\_dbl()} (viz kapitola~\ref{kap:iterace-nad-vektory}).

\hypertarget{kap:funkce}{%
\chapter{Funkce}\label{kap:funkce}}

Funkce jsou základní stavební kámen v~R: všechno, co se v~R děje, je volání funkce. Proto se potřebujete naučit, jak přesně funkce používat. Je také velmi užitečné se naučit vytvářet vlastní funkce, protože vám to umožní výrazně zjednodušit a zautomatizovat mnoho výpočtů.

V~této kapitole se naučíte

\begin{itemize}
\tightlist
\item
  k~čemu funkce slouží,
\item
  jak je vytvářet,
\item
  jak je používat a
\item
  jak se hledají proměnné ve funkcích použité
\end{itemize}

\hypertarget{funkce-a-jejich-uux17eituxed}{%
\section{Funkce a jejich užití}\label{funkce-a-jejich-uux17eituxed}}

Pojem funkce znáte z~matematiky. Volně řečeno, funkce je nějaký předpis, který bere vstupy, nějak je využije a vrátí nějaký výstup. Funkce může např.~vzít vektor pozorování, spočítat z~nich průměr a ten vrátit jako svůj výstup. Tento význam mají funkce i~v~R.
Technicky přesněji je funkce zapouzdřený kus kódu s~jasným rozhraním (interface). Uživatel nemusí vědět nic o~tom, co se děje uvnitř funkce~-- stačí mu vědět, jak funkci zavolat (jaké má jméno a jaké bere vstupní parametry) a jaké vrací hodnoty. Jako příklad si představte funkci \texttt{mean()}, kterou už znáte. Abyste ji mohli použít, nepotřebujete vědět nic o~tom, jak je funkce naprogramovaná. Stačí, když znáte její jméno, seznam parametrů, které bere, a~rozumíte tomu, jakou hodnotu vrací.

Existuje několik důvodů, proč vytváříme a používáme funkce:

\begin{itemize}
\tightlist
\item
  Některé řádky kódu spouštíme znovu a znovu. Pokaždé dané řádky kopírovat je hloupé: váš výsledný kód by byl zbytečně dlouhý a nepřehledný. Navíc při kopírování vznikne snadno chyba, a~to zejména v~situaci, kdy v~kódu potřebujete změnit jména proměnných. Rozkopírovaný kód se také špatně udržuje: pokud chcete něco změnit, musíte to změnit na mnoha místech a doufat, že jste na žádné nezapomněli. Při změnách také snadno něco pokazíte. Pokud jste naproti tomu svůj kód uložili do funkce, stačí, když jej změníte na jednom jediném místě.
\item
  Je dobré oddělit kód a jeho interface. Pak můžeme vlastní kód snadno změnit. Pokud se nezměnil interface, je volání kódu stále stejné, takže nemusíme měnit nic jiného.
\item
  Je snazší předat uživateli funkci než kód. Uživatel (včetně vašeho budoucího já) nemusí tušit, co se děje uvnitř; stačí mu, když ví, jak funkci spustit.
\item
  Kód je modulárnější, úspornější a lépe se čte a udržuje. Pamatujte, že váš skript musí být schopen přečíst a porozumět mu nejen počítač, ale také lidé (minimálně vy sami v~budoucnosti).
\end{itemize}

Ukažme si to na příkladu. Řekněme, že chceme normovat několik vektorů tak, že každé hodnotě ve vektoru přiřadíme odpovídající hodnotu v~kumulativní distribuční funkci. Srovnejte následují dvě možnosti: kód, který vznikl rozkopírováním:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{e1 }\OtherTok{\textless{}{-}} \FunctionTok{ecdf}\NormalTok{(x1)}
\NormalTok{x1n }\OtherTok{\textless{}{-}} \FunctionTok{e1}\NormalTok{(x1)}
\NormalTok{e2 }\OtherTok{\textless{}{-}} \FunctionTok{ecdf}\NormalTok{(x2)}
\NormalTok{x2n }\OtherTok{\textless{}{-}} \FunctionTok{e2}\NormalTok{(x2)}
\NormalTok{e3 }\OtherTok{\textless{}{-}} \FunctionTok{ecdf}\NormalTok{(x3)}
\NormalTok{x3n }\OtherTok{\textless{}{-}} \FunctionTok{e3}\NormalTok{(x3)}
\NormalTok{e4 }\OtherTok{\textless{}{-}} \FunctionTok{ecdf}\NormalTok{(x4)}
\NormalTok{x4n }\OtherTok{\textless{}{-}} \FunctionTok{e4}\NormalTok{(x4)}
\end{Highlighting}
\end{Shaded}

s~kódem pomocí funkce:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{normuj }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x) \{}
\NormalTok{    e }\OtherTok{\textless{}{-}} \FunctionTok{ecdf}\NormalTok{(x)}
    \FunctionTok{e}\NormalTok{(x)}
\NormalTok{\}}
\NormalTok{x1n }\OtherTok{\textless{}{-}} \FunctionTok{normuj}\NormalTok{(x1)}
\NormalTok{x2n }\OtherTok{\textless{}{-}} \FunctionTok{normuj}\NormalTok{(x2)}
\NormalTok{x3n }\OtherTok{\textless{}{-}} \FunctionTok{normuj}\NormalTok{(x3)}
\NormalTok{x4n }\OtherTok{\textless{}{-}} \FunctionTok{normuj}\NormalTok{(x4)}
\end{Highlighting}
\end{Shaded}

Kód napsaný s pomocí nové funkce je přehlednější a stručnější: čím více vektorů chcete normovat, tím více řádků kódu ušetříte. Je také menší šance, že při kopírování něco pokazíte (např.~zapomenete na jeden řádek, kde se volá funkce \texttt{ecdf()} nebo v~posledním řádku zapomenete změnit \texttt{x1} na \texttt{x4}). Kód napsaný s~pomocí funkce se také lépe udržuje. Představte si, že se rozhodnete svá data normovat jinak, např.~tak, že spočítáte jejich \(z\)-skóre. V~prvním případě budete muset přepsat celý kód. Ve druhém stačí změnit jen tělo funkce \texttt{normuj()}. Kód napsaný pomocí funkce navíc šetří operační paměť počítače, protože nezaplevelil pracovní prostředí~R čtyřmi mezivýpočty (funkcemi \texttt{e1()} až \texttt{e4()}).

Pokud to zobecníme, svůj kód byste měli přepsat jako funkci v~jednom z~několika následujících případů:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\item
  Pokud nějaký kus kódu rozkopírováváte, měli byste z~něj raději vytvořit funkci. (V~programování obecně platí zásada, že byste se neměli nikdy opakovat, takže každá konkrétní hodnota nebo operace by měla být v~kódu definovaná jen na jednom jediném místě, kde je snadné ji konzistentně změnit.)
\item
  Pokud potřebujete, abyste mohli nějaké funkci předat svůj kód jako parametr, pak jej také potřebujete zabalit do funkce (touto situací se budeme zabývat v~kapitole~\ref{kap:iterace-nad-vektory}).
\item
  Pokud je váš kód velmi dlouhý (nevejde se na obrazovku), pak byste měli zvážit jeho rozdělení na kusy. Zde se nabízí dvě možnosti: (a)~rozdělit kód na kusy vizuálně pomocí komentářů a hlaviček (RStudio umožňuje vložit do kódu komentářové hlavičky klávesovou zkratkou \texttt{Ctrl}-\texttt{Shift}-\texttt{R}; zobrazuje je pak vlevo dole v~okně editoru a případně v~osnově v~pravém pruhu vedle editoru, což zapnete ikonkou osnovy); nebo (b)~rozdělit svůj kód na funkce. (Stejně tak, pokud vytvoříte funkci, jejíž kód je delší než jedna obrazovka, měli byste zvážit ji rozdělit do více kratších funkcí, protože tím výrazně zvýšíte čitelnost svého kódu.)
\end{enumerate}

Pokud jste na pochybách, zda vytvořit funkci, raději ji vytvořte. Většina začátečníků chybuje spíše tím, že vytváří složitý dlouhý monolitický kód, než že by jej příliš členila do jednotlivých funkcí.

\hypertarget{tvorba-funkce}{%
\section{Tvorba funkce}\label{tvorba-funkce}}

V~R je funkce objekt jako jakýkoli jiný. To znamená, že vytvořenou funkci jde přiřadit do proměnné, funkci jde předat jako parametr jiné funkci (viz např.~kapitola~\ref{kap:iterace-nad-vektory}), funkci můžeme vytvořit i~uvnitř jiné funkce (vznikne tzv.~\emph{nested function}) a jedna funkce může vracet jinou funkci jako svou hodnotu (takto vráceným funkcím se říká ``uzávěry'', \emph{closures}; příkladem takové uzávěry jsou funkce \texttt{e()}, které vrací funkce \texttt{ecdf()} použitá výše).
Funkce v~R nemusejí být \emph{čisté funkce}, ale mohou mít i~vedlejší účinky (\emph{side effects}). Příkladem takové funkce je např.~funkce \texttt{print()}~-- místo, aby vracela nějakou hodnotu, vypíše svůj parametr nějakým způsobem do konzoly. Je jednodušší a bezpečnější psát čisté funkce bez vedlejších účinků.
V~této kapitole se podíváme pouze na základy psaní funkcí v~R. Mnohem podrobnější informace najdete ve \citet{WickhamAdvR}, kap.~6, která je dostupná i~na \url{http://adv-r.had.co.nz/Functions.html}.

Funkci tvoří v~R tři části:

\begin{itemize}
\tightlist
\item
  interface funkce, tj.~parametry, které funkce bere;
\item
  tělo funkce, tj.~kód funkce a
\item
  prostředí (\emph{environment}) funkce.
\end{itemize}

Všimněte si, že jméno funkce není její součástí. Funkce je v~R objekt, který může být k~nějakému jménu přiřazen pomocí klasického přiřazovacího operátoru šipka~(\texttt{\textless{}-}), ale také nemusí. Pokud funkci takto přiřadíme do proměnné, vznikne normální pojmenovaná funkce, kterou můžeme volat jménem této proměnné. Pokud funkci do proměnné neuložíme, vznikne \emph{anonymní funkce}. Použití anonymních funkcí uvidíte v~kapitole~\ref{kap:iterace-nad-vektory}.

Pojmenovanou funkci tedy vytvoříme tak, že výsledek vrácený funkcí \texttt{function()} uložíme do proměnné. Touto proměnnou bude jméno nové funkce. Toto jméno musí samozřejmě splňovat všechny nároky na platné názvy proměnných v~R, viz oddíl~\ref{sec:variables-names}. Navíc byste je měli zvolit tak, aby bylo stručné, jednoznačné a jasně vystihlo, co funkce dělá. Zároveň by nemělo překrýt jméno jiné funkce nebo proměnné. Hadley Wickham doporučuje, že by jméno funkce mělo být sloveso nebo případně podstatné jméno, pokud jasně popisuje dobře definovaný výsledek (jako např.~jméno funkce \texttt{mean()}).
V~kulatých závorkách za \texttt{function} uveďte čárkami oddělený seznam parametrů funkce, tj.~vstupních nebo také nezávislých proměnných. Také jména parametrů funkce byste měli zvolit tak, aby se dobře pamatovala a aby jasně vystihla, jakou hodnotu mají obsahovat. Také byste se měli snažit dodržet obvyklé konvence v~R, např.~pojmenovat parametr pro vyřazení hodnot~\texttt{NA} z~výpočtu jménem \texttt{na.rm} apod. Vstupní parametry mohou v~principu obsahovat data nebo různé volby (např.~jak zacházet s~hodnotami~\texttt{NA}). V~R je zvykem dát datové proměnné na první místo a volby uvést až za ně.
Tělo funkce je výraz uvedený za koncovou kulatou závorkou za \texttt{function}.

Novou funkci tedy vytvoříme takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{jmeno\_funkce }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(parametry\_funkce\_oddělené\_čárkami)}
\NormalTok{    výraz\_který\_funkce\_vyhodnocuje}
\end{Highlighting}
\end{Shaded}

Pokud tělo funkce obsahuje víc než jeden výraz, je třeba tyto výrazy sbalit do bloku tím, že je uzavřeme do složených závorek:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{jmeno\_funkce }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(parametry\_funkce\_oddělené\_čárkami) \{}
\NormalTok{    výraz }\DecValTok{1}
\NormalTok{    výraz }\DecValTok{2}
\NormalTok{    ...}
\NormalTok{    výraz n}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Funkce nemusí mít žádné parametry ani žádný kód. Pokud má funkce nějaký kód, pak vrací poslední vyhodnocený výraz jako svoji hodnotu.
Pokud je třeba vrátit hodnotu někde jinde než jako poslední výraz v~těle funkce, použijeme funkci \texttt{return()}~-- ta vrátí hodnotu funkce a zároveň ukončí její běh. To se používá typicky v~situaci, kdy pro některé hodnoty vstupů má funkce hned na začátku vrátit nějaký výsledek (např.~\texttt{NA}), místo toho, aby něco složitě počítala.
(Pokud funkce vrací výsledek zabalený do funkce \texttt{invisible()}, funkce sice vrací hodnotu, ale při použití v~konzole výsledek nevypíše.)

Řekněme, že chceme vytvořit funkci, která vezme dvě čísla a vrátí jejich násobek. Tuto funkci vytvoříme takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{vynasob }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x, y)}
\NormalTok{    x }\SpecialCharTok{*}\NormalTok{ y}
\end{Highlighting}
\end{Shaded}

Snadno si ověříme, že výsledkem je opravdu funkci a že funguje tak, jak má:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{class}\NormalTok{(vynasob)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "function"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{vynasob}\NormalTok{(}\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{vynasob}\NormalTok{(}\DecValTok{7}\NormalTok{, }\DecValTok{8}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 56
\end{verbatim}

Pokud funkci plánujete používat hodně a dlouho, měli byste ji zabezpečit proti špatným vstupům. To můžeme udělat dvěma způsoby: buď chceme, aby funkce zhavarovala, nebo aby vypsala varování a vrátila~\texttt{NA}. Druhý případ je jednou ze situací, kdy použijeme funkci \texttt{return()}. Řekněme, že chceme, aby naše funkce \texttt{vynasob()} vypsala varování a vrátila~\texttt{NA} v~případě, že vstupní proměnné~\texttt{x} a \texttt{y} nebudou číselné vektory o~délce jedna. To můžeme udělat např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{vynasob }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x, y) \{}
    \ControlFlowTok{if}\NormalTok{ (}\SpecialCharTok{!}\FunctionTok{is.vector}\NormalTok{(x) }\SpecialCharTok{||} \SpecialCharTok{!}\FunctionTok{is.vector}\NormalTok{(y) }\SpecialCharTok{||} \SpecialCharTok{!}\FunctionTok{is.numeric}\NormalTok{(x) }\SpecialCharTok{||} \SpecialCharTok{!}\FunctionTok{is.numeric}\NormalTok{(y) }\SpecialCharTok{||}
        \FunctionTok{length}\NormalTok{(x) }\SpecialCharTok{!=} \DecValTok{1} \SpecialCharTok{||} \FunctionTok{length}\NormalTok{(y) }\SpecialCharTok{!=} \DecValTok{1}\NormalTok{) \{}
        \FunctionTok{warning}\NormalTok{(}\StringTok{"Obě vstupní proměnné musejí být číselný skalár.}\SpecialCharTok{\textbackslash{}n}\StringTok{"}\NormalTok{)}
        \FunctionTok{return}\NormalTok{(}\ConstantTok{NA}\NormalTok{)}
\NormalTok{    \}}
\NormalTok{    x }\SpecialCharTok{*}\NormalTok{ y}
\NormalTok{\}}
\FunctionTok{vynasob}\NormalTok{(}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 6
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{vynasob}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning in vynasob("a", 3): Obě vstupní proměnné musejí být číselný skalár.
\end{verbatim}

\begin{verbatim}
## [1] NA
\end{verbatim}

Všimněte si, že funkce \texttt{return()} vrátí hodnotu~\texttt{NA} a ukončí běh funkce, takže pokud je podmínka splněná, na vyhodnocení výrazu \texttt{x\ *\ y} vůbec nedojde.

Pokud chcete funkci ukončit chybovým hlášením, když jsou vstupy špatné, můžete použít funkce \texttt{stop()} a \texttt{stopifnot()}, viz oddíl~@ref(). Naši funkci bychom v~tom případě mohli přepsat např.~do tvaru:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{vynasob }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x, y) \{}
    \FunctionTok{stopifnot}\NormalTok{(}\FunctionTok{is.vector}\NormalTok{(x) }\SpecialCharTok{\&\&} \FunctionTok{is.vector}\NormalTok{(y) }\SpecialCharTok{\&\&} \FunctionTok{is.numeric}\NormalTok{(x) }\SpecialCharTok{\&\&} \FunctionTok{is.numeric}\NormalTok{(y) }\SpecialCharTok{\&\&}
        \FunctionTok{length}\NormalTok{(x) }\SpecialCharTok{==} \DecValTok{1} \SpecialCharTok{\&\&} \FunctionTok{length}\NormalTok{(y) }\SpecialCharTok{==} \DecValTok{1}\NormalTok{)}
\NormalTok{    x }\SpecialCharTok{*}\NormalTok{ y}
\NormalTok{\}}
\FunctionTok{vynasob}\NormalTok{(}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 6
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{vynasob}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error in vynasob("a", 3): is.vector(x) && is.vector(y) && is.numeric(x) && is.numeric(y) &&  .... is not TRUE
\end{verbatim}

Parametry funkce mohou mít implicitní hodnoty~-- pokud není hodnota parametru zadána, vezme se jeho implicitní hodnota. Jako implicitní hodnota se volí nejčastější hodnota nebo nejbezpečnější hodnota. Většina funkcí v~R, které mají parametr \texttt{na.rm}, mají tento parametr např.~implicitně nastavené na \texttt{na.rm\ =\ FALSE}, protože je bezpečnější implicitně žádné hodnoty nevyřazovat. Implicitní hodnota se nastavuje přímo v~seznamu parametrů v~kulatých závorkách za voláním \texttt{function()}.
V~následující funkci má proměnná~\texttt{y} přiřazenou implicitní hodnotu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{vynasob2 }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x, }\AttributeTok{y =} \DecValTok{2}\NormalTok{)}
\NormalTok{    x }\SpecialCharTok{*}\NormalTok{ y}
\FunctionTok{vynasob2}\NormalTok{(}\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 12
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{vynasob2}\NormalTok{(}\DecValTok{3}\NormalTok{)  }\CommentTok{\# y = 2, implicitni hodnota}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 6
\end{verbatim}

Parametry funkcí jsou vyhodnocovány líně (\emph{lazy evaluation}). To znamená, že se jejich hodnota vyhodnotí až ve chvíli, kdy jsou opravdu použité. Pokud tedy není parametr ve funkci vůbec použit, R~nevyhlásí chybu, když hodnotu parametru nezadáte.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{f }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x, y)}
    \DecValTok{3} \SpecialCharTok{*}\NormalTok{ x}
\FunctionTok{f}\NormalTok{(}\DecValTok{2}\NormalTok{, }\DecValTok{4}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 6
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{f}\NormalTok{(}\DecValTok{2}\NormalTok{)  }\CommentTok{\# R nevyhlásí chybu, protože y není reálně použito}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 6
\end{verbatim}

Líné vyhodnocování parametrů umožňuje mimo jiné i~zadat implicitní hodnoty parametrů, které jsou spočítané z~jiných parametrů. Můžeme např.~vytvořit funkci~\texttt{f()}, kde implicitní hodnota parametru~\texttt{y} bude záviset na zadané hodnotě parametru~\texttt{x}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{f }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x, }\AttributeTok{y =} \DecValTok{3} \SpecialCharTok{*}\NormalTok{ x }\SpecialCharTok{+} \DecValTok{1}\NormalTok{)}
    \FunctionTok{c}\NormalTok{(x, y)}
\FunctionTok{f}\NormalTok{(}\DecValTok{2}\NormalTok{)  }\CommentTok{\# y je implicitně 3 * 2 + 1}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2 7
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{f}\NormalTok{(}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)  }\CommentTok{\# y je explicitně zadáno jako 3}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2 3
\end{verbatim}

Veškeré proměnné definované uvnitř funkce jsou lokální, tj.~platí pouze uvnitř funkce a neovlivní nic mimo funkci. Při ukončení běhu funkce zaniknou (leda byste vytvořili uzávěru, viz dále). To platí i~pro parametry funkce~-- pokud se do nich uvnitř funkce pokusíte uložit nějakou hodnotu, R~tiše vytvoří lokální proměnnou se stejným jménem, které zastíní vlastní parametr~-- jeho hodnota nebude ovlivněna.
Ukažme si to na příkladu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{a }\OtherTok{\textless{}{-}} \DecValTok{3}
\NormalTok{b }\OtherTok{\textless{}{-}} \DecValTok{7}
\NormalTok{f }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x, y) \{}
\NormalTok{    a }\OtherTok{\textless{}{-}} \DecValTok{5}
\NormalTok{    x }\OtherTok{\textless{}{-}} \DecValTok{2} \SpecialCharTok{*}\NormalTok{ x}
\NormalTok{    a }\SpecialCharTok{+}\NormalTok{ x }\SpecialCharTok{+}\NormalTok{ y}
\NormalTok{\}}
\FunctionTok{f}\NormalTok{(b, }\DecValTok{3}\NormalTok{)  }\CommentTok{\# vrací 5 + 2 * 7 + 3 = 22}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 22
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{a  }\CommentTok{\# hodnota a se mimo funkci nezměnila}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{b  }\CommentTok{\# ani hodnota b se mimo funkci nezměnila}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 7
\end{verbatim}

Vždy byste se měli snažit o~to, aby každá vaše funkce byla čitelná a srozumitelná nejen stroji, ale i~člověku. (Možná ji v~budoucnu budete muset mírně změnit. Pokud jí nebudete rozumět, budete ji muset napsat zbrusu znova.) K~tomu vám výrazně pomůže odsazení kódu (doporučuji používat odsazení o~4~mezery, ne v~R obvyklé 2~mezery) a obecně i~dodržování jednotného stylu kódování, viz oddíl~\ref{sec:basics-skripts}.

Pokud hodláte svoje funkce používat dlouhodobě, měli byste je opatřit komentářem dvou typů. První typ komentářů kopíruje nápovědu k~funkcím definovaných v~balících. Před definici funkce doporučuji si vždy poznačit co funkce dělá, jaké hodnoty mají mít její parametry (co tyto hodnoty znamenají a v~jaké datové struktuře a typu mají být uložené) a jakou hodnotu funkce vrací (co výsledek znamená a v~jaké datové struktuře a typu je uložen). Neuškodí také, když si napíšete příklad použití funkce. Až se k~ní později vrátíte, nebudete muset složitě přemýšlet a zkoušet, jak funkci použít. Komentář pro funkci \texttt{vynásob()} by mohl vypadat např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# funkce vynasob() vynásobí dvě čísla}
\CommentTok{\# vstupy:}
\CommentTok{\#   {-} x ... (numeric) první číslo, které má být vynásobeno}
\CommentTok{\#   {-} y ... (numeric) druhé číslo, které má být vynásobeno}
\CommentTok{\# výstup:}
\CommentTok{\#   {-} (numeric) součin čísel x a y}
\CommentTok{\# příklad použití:}
\CommentTok{\#   vynasob(2, 3)}
\NormalTok{vynasob }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x, y)}
\NormalTok{    x }\SpecialCharTok{*}\NormalTok{ y}
\end{Highlighting}
\end{Shaded}

Druhý typ komentářů patří do vlastního těla funkce. Zde je dobré si poznamenat, jak funkce funguje. Není až tak důležité vysvětlovat co který kus kód dělá a jak to dělá, protože to by mělo být zřejmé z~vlastního kódu (pokud to jasné není, měli byste kód přepsat tak, aby to jasné bylo). Spíše je potřeba si poznamenat, proč to dělá. Pokud váš kód také nepracuje obecně s~každým možným typem vstupů, je dobré si poznamenat předpoklady, za kterých bude funkce pracovat správně.

Po napsání byste měli každou funkci vyzkoušet s~různými vstupy. U~platných vstupů byste měli hlídat, že funkce vrací hodnoty, jaké vracet má. U~neplatných vstupů by funkce měla co nejdříve ``zemřít'' a vrátit přitom nějakou smysluplnou chybovou hlášku. (Je velmi nepříjemné, pokud se chybná hodnota dlouho táhne výpočtem, protože pak může být těžké zjistit, kde se co pokazilo. Proto se snažte dodržovat princip ``die early''.) Pokud víte něco o~testování chyb v~softwaru obecně, můžete se podívat na balík \textbf{testthat}, který umožňuje efektivně psát jednotkové testy (\emph{unit tests}). Dokumentaci balíku najdete na viz \url{http://r-pkgs.had.co.nz/tests.html}.

\hypertarget{sec:function-call}{%
\section{Volání funkce}\label{sec:function-call}}

Funkce se vždy volá se závorkami, i~kdyby neměla žádné parametry. Pokud zavoláme funkci bez závorek, vypíše se kód funkce (její tělo):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{hello\_world }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{()}
    \FunctionTok{print}\NormalTok{(}\StringTok{"Ahoj, světe!"}\NormalTok{)}
\FunctionTok{hello\_world}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Ahoj, světe!"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{hello\_world}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## function()
##     print("Ahoj, světe!")
\end{verbatim}

Parametry mohou být funkci předány třemi způsoby:

\begin{itemize}
\tightlist
\item
  jménem, např.~\texttt{f(a\ =\ 1,\ b\ =\ 2)}~-- v~tomto případě nezáleží na pořadí parametrů,
\item
  pozicí, např.~ve funkci \texttt{f(a,\ b)} znamená volání \texttt{f(1,\ 2)}, že \(a=1\) a \(b=2\), nebo
\item
  pokud má parametr implicitní hodnotu, je možné jej vynechat~-- R~vezme místo parametru implicitní hodnotu.
\end{itemize}

Při zadání parametru jménem R~umožňuje jméno parametru zkrátit, pokud je zkratka jednoznačná (tomu se říká \emph{partial matching}). Ve funkci \texttt{f(number,\ notalk)} je např.~možné první parametr zkrátit na \texttt{num} i \texttt{nu}, ale ne na \texttt{n}, protože \texttt{n} není jednoznačné a R~by nevědělo, zda \texttt{n} znamená \texttt{number}, nebo \texttt{notalk}. Zkracování parametrů zjednodušuje interaktivní práci; při psaní skriptů se však výrazně nedoporučuje, protože autor funkce by později mohl přidat další parametr a zkrácené jméno už by nemuselo být jednoznačné.

Předávání parametrů těmito třemi způsoby je možné libovolně míchat, tj.~volat některé parametry pozicí, jiné jménem a další (s~implicitní hodnotou) vynechat. V~takovém případě postupuje R~takto:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  vezme parametry volané plným jménem (\emph{exact matching}) a přiřadí jim hodnoty,
\item
  vezme parametry volané zkráceným jménem (\emph{partial matching}) a přiřadí jim hodnoty a
\item
  vezme parametry pozičně.
\end{enumerate}

Ukážeme si to na příkladu funkce \texttt{mean()}. Tato funkce má podle dokumentace pro číselné vektory použití \texttt{mean(x,\ trim\ =\ 0,\ na.rm\ =\ FALSE,\ ...)}. Následující výrazy jsou tedy ekvivalentní:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{mean}\NormalTok{(x, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{)}
\FunctionTok{mean}\NormalTok{(x, }\AttributeTok{trim =} \DecValTok{0}\NormalTok{, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{)}
\FunctionTok{mean}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{trim =} \DecValTok{0}\NormalTok{, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{)}
\FunctionTok{mean}\NormalTok{(x, }\DecValTok{0}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Výraz \texttt{mean(x,\ TRUE)} už však ekvivalentní není a skončil by chybou.

Pokud nechcete mít v~kódu zmatek, doporučuji abyste pozicí volali pouze několik první nejdůležitějších parametrů. Všechny ostatní parametry volejte plným jménem. parametry volané jménem uveďte až za parametry volané pozicí. Ve funkci \texttt{mean()} tedy pozičně předejte jen průměrovaný vektor a ostatní parametry volejte jménem, např.:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{mean}\NormalTok{(x, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\hypertarget{speciuxe1lnuxed-parametr-...}{%
\section{\texorpdfstring{Speciální parametr \texttt{...}}{Speciální parametr ...}}\label{speciuxe1lnuxed-parametr-...}}

Kromě explicitně vyjmenovaných parametrů může funkce v~R obsahovat i~speciální parametr~tři tečky (\texttt{...}). Tento parametr absorbuje libovolný počet parametrů na dané pozici; všechny parametry uvedené za ním musejí být tedy volány plným jménem.

Parametr \texttt{...} se používá zejména ve dvou situacích: 1)~když počet parametrů není dopředu znám a 2)~když chceme některé parametry předat z~naší funkce další funkci, kterou naše funkce volá.
Příkladem funkce, která bere libovolný počet vstupních parametrů, je funkce \texttt{paste()}, která umožňuje spojit libovolný počet řetězců: buď spojuje vektory po prvcích, nebo kolabuje vektor do jednoho řetězce. Počet parametrů není znám dopředu, proto funkce paste používá parametr~\texttt{...}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{paste}\NormalTok{(}\StringTok{"Ahoj,"}\NormalTok{, }\StringTok{"lidi."}\NormalTok{, }\StringTok{"Jak se máte?"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Ahoj, lidi. Jak se máte?"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{paste}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## function (..., sep = " ", collapse = NULL, recycle0 = FALSE) 
## .Internal(paste(list(...), sep, collapse, recycle0))
## <bytecode: 0x5600df4e9eb8>
## <environment: namespace:base>
\end{verbatim}

Pokud chcete napsat vlastní funkci s~libovolným počtem parametrů, můžete použít následující trik: parametr~\texttt{...} vložíme do seznamu, s~jehož prvky pak už pracujeme obvyklým způsobem. Jako příklad použití \texttt{...} vytvoříme funkci, která vezme libovolný počet atomických vektorů a vrátí součet počtu prvků všech těchto vektorů:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{count\_all\_members }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(...) \{}
\NormalTok{    param }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(...)}
    \FunctionTok{sum}\NormalTok{(purrr}\SpecialCharTok{::}\FunctionTok{map\_int}\NormalTok{(param, length))}
\NormalTok{\}}
\FunctionTok{count\_all\_members}\NormalTok{(}\DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{count\_all\_members}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{10}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{100}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{1000}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1111
\end{verbatim}

(Co přesně dělá funkce \texttt{map\_int()} z~balíku **purrr*, vysvětlíme v~kapitole~\ref{kap:iterace-nad-vektory}.)

Příkladem funkce, která předává svoje parametry dál, je funkce \texttt{print()}, která dokáže vypsat do konzoly obsah mnoha různých objektů~-- pro každý objekt volá speciální metodu, tj.~funkci přizpůsobenou tomuto objektu. Proto je třeba mít možnost funkci \texttt{print()} předat libovolné parametry, které funkce \texttt{print()} předá dál zvolené metodě:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{print}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## function (x, ...) 
## UseMethod("print")
## <bytecode: 0x5600dfa00540>
## <environment: namespace:base>
\end{verbatim}

(O~objektech a metodách se dozvíte více v~kapitole~\ref{kap:objekty}.)

\hypertarget{scoping-rules-a-uzuxe1vux11bry}{%
\section{Scoping rules a uzávěry}\label{scoping-rules-a-uzuxe1vux11bry}}

Když R hledá hodnotu nějaké proměnné, prochází série různých prostředí (\emph{environment}). Pokud např.~zadáte výpis proměnné~\texttt{x} v~konzoli, začíná R hledat \texttt{x} nejdříve v~globální prostředí (tj.~základním pracovním prostředí~R). Když ji tam nenajde, pokračuje do mateřského prostředí (\emph{parental environment}) globálního prostředí, což je typicky poslední načtený balík. Pokud ji nenajde ani tam, pokračuje do dalšího mateřského prostředí atd. Pokud ji nikde nenajde, vypíše R chybu.

Situace ve funkcích je zajímavější. R~používá tzv.~\emph{lexical scoping}, což znamená, že vyhledávání začíná v~prostředí, ve kterém byla funkce \emph{definovaná.} Pokud je funkce zadefinovaná v~globálním prostředí, vše funguje stejně jako v~předchozím případě: pokud se nějaká proměnná nenajde v~prostředí funkce, bude se dál hledat v~globálním prostředí:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{a }\OtherTok{\textless{}{-}} \DecValTok{7}
\NormalTok{nasob\_a }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x)}
\NormalTok{    a }\SpecialCharTok{*}\NormalTok{ x}
\FunctionTok{nasob\_a}\NormalTok{(}\DecValTok{5}\NormalTok{)  }\CommentTok{\# neskončí chybou, ale vrátí 35}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 35
\end{verbatim}

Náš kód neskončí chybou, protože když R nenašlo proměnnou~\texttt{a} v~těle funkce ani mezi jejími parametry, začne ji hledat v~globálním prostředí, kde ji (v~našem případě) najde. Volání funkce \texttt{nasob\_a()} by skončilo chybou jen v~případě, že by R nenašlo proměnnou \texttt{a} ani v~globálním prostředí, ani v~žádném balíku načteném do paměti. Použití proměnné, která není definovaná ve funkci, ale v~globálním prostředí (jedná se o~tzv.~\emph{globální proměnnou}), umožňuje dělat zajímavé triky; zároveň se však takový kód špatně ladí. Snadno se totiž může stát, že jste proměnnou prostě jen zapomněli definovat~-- pokud daná proměnná žije v~globálním prostředí, dostanete divné chování. Pokud však máte v~RStudiu zapnutou diagnostiku, RStudio označí proměnné, které nejsou v~daném rozsahu (\emph{scope}) definované žlutou vlnovkou a na začátek řádku přidá výstražný trojúhelníček. (Víc o~diagnostice v~RStudiu najdete na \url{https://goo.gl/ovWFpE}.)

Hodnoty globálních proměnných hledá R dynamicky (\emph{dynamic lookup}). To znamená, že začne proměnnou hledat v~místě, kde byla funkce definovaná, ale použije její aktuální hodnotu, jak ukazuje následující případ:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{a }\OtherTok{\textless{}{-}} \DecValTok{7}
\NormalTok{nasob\_a }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x)}
\NormalTok{    a }\SpecialCharTok{*}\NormalTok{ x}
\FunctionTok{nasob\_a}\NormalTok{(}\DecValTok{5}\NormalTok{)  }\CommentTok{\# a je nyní 7}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 35
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{a }\OtherTok{\textless{}{-}} \DecValTok{5}
\FunctionTok{nasob\_a}\NormalTok{(}\DecValTok{5}\NormalTok{)  }\CommentTok{\# a je nyní 5}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 25
\end{verbatim}

Pokud se ve funkci pokusíte něco přiřadit do globální proměnné, R~automaticky vytvoří lokální proměnnou stejného jména, která zamaskuje globální proměnnou. Pomocí operátoru šipka (\texttt{\textless{}-}) tedy není možné přiřazovat hodnoty mimo vlastní tělo funkce:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{a }\OtherTok{\textless{}{-}} \DecValTok{5}
\NormalTok{nasob\_a }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x) \{}
\NormalTok{    a }\OtherTok{\textless{}{-}} \DecValTok{7}
\NormalTok{    a }\SpecialCharTok{*}\NormalTok{ x  }\CommentTok{\# hodnota a je ve funkci lokálně 7}
\NormalTok{\}}
\FunctionTok{nasob\_a}\NormalTok{(}\DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 35
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{a  }\CommentTok{\# hodnota a je mimo tělo funkce stále 5}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 5
\end{verbatim}

Pokud je funkce~\texttt{g()} definovaná uvnitř jiné funkce~\texttt{f()}, pak vyhledávání začíná v~prostředí vnitřní funkce~\texttt{g()}, a~pak v~prostředí vnější funkce~\texttt{f()}. To je možné (mimo jiné) využít k~tvorbě tzv.~\emph{function factories}. Ukažme si to na velmi konvenčním příkladu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{n }\OtherTok{\textless{}{-}} \DecValTok{17}
\NormalTok{make\_power }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(n) \{}
\NormalTok{    g }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x)}
\NormalTok{        x }\SpecialCharTok{\^{}}\NormalTok{ n}
\NormalTok{    g}
\NormalTok{\}}
\NormalTok{square }\OtherTok{\textless{}{-}} \FunctionTok{make\_power}\NormalTok{(}\DecValTok{2}\NormalTok{)}
\NormalTok{cube }\OtherTok{\textless{}{-}} \FunctionTok{make\_power}\NormalTok{(}\DecValTok{3}\NormalTok{)}
\FunctionTok{square}\NormalTok{(}\DecValTok{2}\NormalTok{)  }\CommentTok{\# ve funkci square() je n lokálně rovno 2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{cube}\NormalTok{(}\DecValTok{2}\NormalTok{)  }\CommentTok{\# ve funkci cube() je n lokálně rovno 3}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 8
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{n}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 17
\end{verbatim}

Funkce \texttt{make\_power()} vrací funkci jedné proměnné. Tyto funkce však obsahují kromě formálního parametru~\texttt{x} také volný parametr~\texttt{n}. Když R hledá jeho hodnotu, začne nejdříve v~prostředí, ve kterém byly funkce \texttt{square()} a \texttt{cube()} definovány. Tato prostředí je prostředí funkce \texttt{make\_power()} ve chvíli, kdy byla tato funkce spuštěna. Funkce \texttt{square()} byla definována v~prostředí, ve kterém bylo \texttt{n\ =\ 2}, a~toto prostředí si s~sebou táhne. Stejně tak funkce \texttt{cube()} si s~sebou táhne prostředí, ve kterém je \texttt{n\ =\ 3}. (Normálně volací prostředí funkce ve chvíli ukončení jejího běhu zaniká a každá funkce je vždy spuštěna z~čistého stavu.)

Funkce \texttt{square()} a \texttt{cube()} jsou tzv.~``uzávěry'' (\emph{closures}). Existují situace, kdy je vytváření uzávěr užitečné. Jindy však uzávěry vzniknou, aniž byste si to výslovně přáli. To pak může být zdrojem překvapivých chyb. Pokud nevíte, co děláte, raději nedefinujte žádné funkce v~těle jiných funkcí a nepoužívejte příliš globální proměnné.

Typická situace, kde se něco pokazí kvůli nepochopení toho, jak R~hledá proměnné, nastává např.~v~následující situaci: Vytvoříme funkci~\texttt{f()}, jejíž hodnota závisí částečně na explicitně zadaném parametru~\texttt{n} a částečně na implicitním (globálním) parametru~\texttt{z}. Funkci~\texttt{f()} pak chceme využít ve funkci~\texttt{g()}, která nastaví hodnotu~\texttt{z} podle svých potřeb. Jak ale ukazuje následující příklad, nebude to fungovat, protože \texttt{z} použité ve funkci~\texttt{f()} se nehledá ve funkci~\texttt{g()}, nýbrž v~globálním prostředí, kde byla funkce~\texttt{f()} definovaná:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{z }\OtherTok{\textless{}{-}} \DecValTok{3}
\NormalTok{f }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(n) n }\SpecialCharTok{*}\NormalTok{ z}
\NormalTok{g }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(a) \{}
\NormalTok{    z }\OtherTok{\textless{}{-}} \DecValTok{7}  \CommentTok{\# neúspěšná snaha nastavit z}
    \FunctionTok{f}\NormalTok{(a)  }\CommentTok{\# f() hledá z v prostředí, kde byla definovaná, ne kde je spuštěná}
\NormalTok{\}}
\FunctionTok{g}\NormalTok{(}\DecValTok{5}\NormalTok{)  }\CommentTok{\# vrátí 15, ne 35, protože z je 3, ne 7!}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 15
\end{verbatim}

Víc se o~funkcích a uzávěrách můžete dočíst v~6.~a~10.~kapitole \citet{WickhamAdvR}, dostupných na \url{http://adv-r.had.co.nz/Functions.html} a \url{http://adv-r.had.co.nz/Functional-programming.html}.

\hypertarget{seznam-uux17eiteux10dnuxfdch-funkcuxed}{%
\section{Seznam užitečných funkcí}\label{seznam-uux17eiteux10dnuxfdch-funkcuxed}}

R~má implementováno velký objem velmi užitečných funkcí. Kapitola Vocabulary v~knize~\citet{WickhamAdvR} uvádí seznam některých velmi užitečných funkcí. Velmi doporučujeme, abyste si tento slovník prošli a naučili se z~něj co nejvíce funkcí. Jejich význam a použití najdete v~dokumentaci. Celá kapitola je dostupná na \url{http://adv-r.had.co.nz/Vocabulary.html}.

\hypertarget{kap:objekty}{%
\chapter{Objekty}\label{kap:objekty}}

R je ve své podstatě objektově orientovaný jazyk: vše, co žije v~prostředí~R, jsou objekty. R~je však velmi zvláštní objektově orientovaný jazyk. Na rozdíl od jiných objektových jazyků nejsou objekty (v~užším smyslu slova) součástí definice vlastního jazyka, ale jsou vytvořeny v~rámci tohoto jazyka. V~důsledku toho (a~dlouhého vývoje~R a jeho předchůdce, jazyka~S) dnes v~R existuje několik různých systémů objektů, z~nichž nejvýznamnější je systém~S3, který je nejpoužívanější a zároveň nejjednodušší. Zde se zaměříme právě na tento systém. (Vysvětlení ostatních systémů OOP v~R najdete v~\citet{WickhamAdvR} v~kapitole~7, která je dostupná na \url{http://adv-r.had.co.nz/OO-essentials.html}.)

V~této kapitole se naučíte

\begin{itemize}
\tightlist
\item
  základní terminologii,
\item
  vytvářet nové objekty, metody a generické funkce a
\item
  používat existující objekty.
\end{itemize}

Cílem zde mimořádně není to, abyste vytvářeli vlastní objekty~-- to není při běžné datové analýze většinou potřeba; cílem je zajistit, že budete mít povšechné povědomí o~tom, jak se s~objekty v~R zachází. K~tomu je užitečné vědět, jak jsou objekty a metody zhruba implementované.

\hypertarget{zuxe1kladnuxed-pojmy-objektovux11b-orientovanuxe9ho-programovuxe1nuxed-pro-laiky}{%
\section{Základní pojmy objektově orientovaného programování (pro laiky)}\label{zuxe1kladnuxed-pojmy-objektovux11b-orientovanuxe9ho-programovuxe1nuxed-pro-laiky}}

Základním pojmem OOP je \emph{objekt}. Objekt je datová struktura s~jasně definovanými metodami, jak s~těmito daty zacházet.
Každý objekt má určitou \emph{třídu}. Třída (\emph{class}) popisuje strukturu dat objektu, vztah k~ostatním třídám objektů (v~rámci dědičnosti) a to, jaké funkce (metody) se volají při práci s~objektem. Dědičnost umožňuje vytvářet mezi objekty hierarchii předků a potomků, kde potomci dědí data a metody od svých předků, mohou je však modifikovat a přidávat k~nim. Dědičnost vytváří hierarchii: potomci dědí vlastnosti a chování předků. Pokud potomek nemá implementovanou nějakou funkci, pak se použije funkce jeho předka.

Např.~objekt třídy \emph{člověk} může obsahovat datové položky jako jméno, příjmení, výšku, váhu apod. Pro třídu \emph{člověk} mohou být definovány nějaké funkce (metody), např.~funkce, která spočítá BMI.
Objekt třídy \emph{manažer} může být logicky svázán s~objektem třídy \emph{člověk}~-- obsahuje stejná data (může obsahovat i~další, např.~seznam podřízených). Stejně tak může využívat metody se stejnými jmény, které však mohou být implementovány odlišně.
Logickou vazbu tříd \emph{člověk} a \emph{manažer} popisuje dědičnost: třída \emph{manažer} je potomek třídy \emph{člověk}.

\hypertarget{systuxe9m-s3}{%
\section{Systém~S3}\label{systuxe9m-s3}}

Systém~S3 používá poměrně neobvyklý přístup k~objektovému programování, tzv.~\emph{generic function OOP}. Tento přístup je jednoduchý (až primitivní), ale funguje velmi dobře a používá jej drtivá většina balíků v~R.
V~normálních OOP jazycích patří objektu nebo třídě jak data, tak metody (funkce). V~R však objektu patří jen data a jméno třídy; metody patří tzv.~generické funkci. Nejjednodušší způsob, jak pochopit strukturu objektu, je nějaký objekt vytvořit.

S3 nemá formální definici tříd. Objekt se vytvoří tak, že se nějaké základní datové struktuře (většinou seznamu) nastaví atribut \texttt{class} na hodnotu jména třídy:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{foo }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{()        }\CommentTok{\# vytvoří prázdný seznam}
\FunctionTok{class}\NormalTok{(foo) }\OtherTok{\textless{}{-}} \StringTok{"foo"}  \CommentTok{\# přiřadí mu třídu foo}
\end{Highlighting}
\end{Shaded}

Alternativně to jde provést naráz pomocí funkce \texttt{structure()}, která nastavuje danému objektu atributy:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{foo }\OtherTok{\textless{}{-}} \FunctionTok{structure}\NormalTok{(}\FunctionTok{list}\NormalTok{(), }\AttributeTok{class =} \StringTok{"foo"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Nyní je proměnná \texttt{foo} objekt třídy \emph{foo}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{class}\NormalTok{(foo)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "foo"
\end{verbatim}

R~nemá žádný mechanismus, který by kontroloval, zda je datová struktura objektu správná. Již vytvořenému objektu je možné přidat nebo ubrat datové sloty (technicky obvykle prvky seznamu) nebo změnit jeho třídu. Někdy se to hodí; nikdy to však nedělejte, pokud opravdu dobře nevíte, co děláte, jinak vznikne velmi těžko předvídatelné chování a těžko dohledatelné chyby.

Aby se zajistilo, že je struktura objektu správná, je vhodné vytvořit \emph{konstruktor}, tj.~funkci, která vytváří objekt. (Funkce jako \texttt{numeric()} jsou také konstruktory.) Ukažme si to na příkladu. Budeme chtít mít objekty třídy \emph{human}, které budou obsahovat datové položky \texttt{name}, \texttt{height} a \texttt{weight}. Nejdříve vytvoříme konstruktor, a~pak jeden objekt:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{human }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(name, height, weight)  }\CommentTok{\# konstruktor}
    \FunctionTok{structure}\NormalTok{(}\FunctionTok{list}\NormalTok{(}\AttributeTok{name =}\NormalTok{ name, }\AttributeTok{height =}\NormalTok{ height, }\AttributeTok{weight =}\NormalTok{ weight),}
              \AttributeTok{class =} \StringTok{"human"}\NormalTok{)}
\NormalTok{adam }\OtherTok{\textless{}{-}} \FunctionTok{human}\NormalTok{(}\StringTok{"Adam"}\NormalTok{, }\DecValTok{173}\NormalTok{, }\DecValTok{63}\NormalTok{)  }\CommentTok{\# tvorba objektu pomocí konstruktoru human()}
\end{Highlighting}
\end{Shaded}

Dědičnost se zajistí tak, že atribut \texttt{class} je vektorem jmen několik tříd~-- zleva doprava od potomků k~předkům. Budeme např.~chtít mít objekty třídy \emph{manager}, které jsou potomky třídy \emph{human}. Opět pro ně vytvoříme konstruktor a jeden objekt:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{manager }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(name, height, weight, rank)  }\CommentTok{\# konstruktor}
    \FunctionTok{structure}\NormalTok{(}\FunctionTok{list}\NormalTok{(}\AttributeTok{name =}\NormalTok{ name, }\AttributeTok{height =}\NormalTok{ height, }\AttributeTok{weight =}\NormalTok{ weight, }\AttributeTok{rank =}\NormalTok{ rank),}
              \AttributeTok{class =} \FunctionTok{c}\NormalTok{(}\StringTok{"manager"}\NormalTok{, }\StringTok{"human"}\NormalTok{))}
\NormalTok{eva }\OtherTok{\textless{}{-}} \FunctionTok{manager}\NormalTok{(}\StringTok{"Eve"}\NormalTok{, }\DecValTok{169}\NormalTok{, }\DecValTok{52}\NormalTok{, }\StringTok{"CEO"}\NormalTok{)  }\CommentTok{\# objekt třídy manager}
\end{Highlighting}
\end{Shaded}

Eva nyní dědí vlastnosti člověka:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{class}\NormalTok{(eva)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "manager" "human"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{inherits}\NormalTok{(eva, }\StringTok{"manager"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{inherits}\NormalTok{(eva, }\StringTok{"human"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Protože je většina objektů v~S3 postavená pomocí seznamů, můžete zjistit strukturu objektu pomocí funkce \texttt{str()}. Hodnotu jednotlivých slotů objektů typu~S3 můžete získat pomocí operátoru~\texttt{\$}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str}\NormalTok{(eva)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 4
##  $ name  : chr "Eve"
##  $ height: num 169
##  $ weight: num 52
##  $ rank  : chr "CEO"
##  - attr(*, "class")= chr [1:2] "manager" "human"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{eva}\SpecialCharTok{$}\NormalTok{rank}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "CEO"
\end{verbatim}

Hlavní pointa systému~S3 spočívá v~tom, že stejně pojmenovaná funkce volá pro každou třídu objektu jinou metodu (jinak implementovanou funkci) přesně uzpůsobenou dané třídě dat. Funkcím, které to dokážou, se říká \emph{generické funkce}. Příkladem generické funkce je funkce \texttt{print()}, která tiskne různé informace v~závislosti na tom, jaká je třída objektu, kterou chceme vytisknout.
Třída \emph{human} zatím nemá definovanou žádnou metodu pro generickou funkci \texttt{print()}, proto zavolá metodu pro seznam:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(adam)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $name
## [1] "Adam"
## 
## $height
## [1] 173
## 
## $weight
## [1] 63
## 
## attr(,"class")
## [1] "human"
\end{verbatim}

Když vytvoříte novou třídu objektu, můžete vytvořit i~novou metodu ke generické funkci tak, že vytvoříte funkci, jejíž jméno má tvar \texttt{jmeno\_genericke\_funkce.jmeno\_tridy}, tj.~jméno generické funkce oddělené tečkou od názvu třídy objektu. Metodu pro tisk objektů třídy \emph{human} vytvoříme např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{print.human }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x)}
    \FunctionTok{cat}\NormalTok{(}\StringTok{"*** Human ***"}\NormalTok{,}
        \FunctionTok{paste}\NormalTok{(}\StringTok{"Name:"}\NormalTok{, x}\SpecialCharTok{$}\NormalTok{name),}
        \FunctionTok{paste}\NormalTok{(}\StringTok{"Height:"}\NormalTok{, x}\SpecialCharTok{$}\NormalTok{height),}
        \FunctionTok{paste}\NormalTok{(}\StringTok{"Weight:"}\NormalTok{, x}\SpecialCharTok{$}\NormalTok{weight),}
        \AttributeTok{sep =} \StringTok{"}\SpecialCharTok{\textbackslash{}n}\StringTok{"}\NormalTok{)}
\FunctionTok{print}\NormalTok{(adam)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## *** Human ***
## Name: Adam
## Height: 173
## Weight: 63
\end{verbatim}

Protože třída \emph{manager} je potomkem třídy \emph{human}, dědí její chování. To znamená, že pokud tato třída nemá definovanou svou metodu \texttt{print()}, pak zavolá metodu svého předka, třídy \emph{human}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{eva  }\CommentTok{\# implicitně se volá funkce print}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## *** Human ***
## Name: Eve
## Height: 169
## Weight: 52
\end{verbatim}

Novou generickou funkci vytvoříme tak, že vytvoříme funkci, která bude obsahovat jediný řádek \texttt{UseMethod("xxx")}, kde \texttt{xxx} je jméno nové generické funkce. Řekněme, že chceme vytvořit novou generickou funkci, která vrátí pro objekty třídy \emph{human} jejich body mass index. Samozřejmě musíme vytvořit i~příslušné metody. Řekněme, že budeme chtít mít různou metodu \texttt{bmi()} pro objekt třídy \emph{human} a objekt třídy \emph{manager}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x)          }\CommentTok{\# generická funkce}
    \FunctionTok{UseMethod}\NormalTok{(}\StringTok{"bmi"}\NormalTok{)}
\NormalTok{bmi.human }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x)    }\CommentTok{\# metoda pro třídu human}
\NormalTok{    x}\SpecialCharTok{$}\NormalTok{weight }\SpecialCharTok{/}\NormalTok{ (x}\SpecialCharTok{$}\NormalTok{height }\SpecialCharTok{/} \DecValTok{100}\NormalTok{) }\SpecialCharTok{\^{}} \DecValTok{2}
\NormalTok{bmi.manager }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x)  }\CommentTok{\# metoda pro třídu manager}
    \StringTok{"classified"}
\end{Highlighting}
\end{Shaded}

Nyní můžeme zjistit, jaký mají Adam a Eva BMI (bohužel je informace o~BMI manažerů tajná):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{bmi}\NormalTok{(adam)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 21.04982
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{bmi}\NormalTok{(eva)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "classified"
\end{verbatim}

Generická funkce může mít i~implicitní metodu, která se použije v~případě, že pro daný typ není žádná metoda k~dispozici. Tato metoda se jmenuje \texttt{default}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi.default }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x)}
    \StringTok{"Unknown class"}
\FunctionTok{bmi}\NormalTok{(}\DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Unknown class"
\end{verbatim}

(Bez definování implicitní metody by předchozí řádek skončil chybou.)

\hypertarget{pruxe1ce-s-objekty}{%
\section{Práce s~objekty}\label{pruxe1ce-s-objekty}}

Ve většině případů nebudete vytvářet vlastní objekty~-- stačí, když budete schopní zacházet s~objekty, které vrátí funkce, které budete používat.

Nejdříve ze všeho potřebujete poznat, zda je nějaká proměnná objekt v~systému~S3. Jsou tři možnosti, jak to můžete udělat: 1)~můžete se podívat, zda je proměnná objekt pomocí funkce \texttt{is.object()}, a~že se nejedná o~objekt v~systému~S4, 2)~můžete použít funkci \texttt{otype()} z~balíku~\textbf{pryr} nebo 3)~se samozřejmě můžete podívat do dokumentace:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{is.object}\NormalTok{(eva) }\SpecialCharTok{\&} \SpecialCharTok{!}\FunctionTok{isS4}\NormalTok{(eva)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{pryr}\SpecialCharTok{::}\FunctionTok{otype}\NormalTok{(eva)  }\CommentTok{\# funkce z balíku pryr}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Registered S3 method overwritten by 'pryr':
##   method      from
##   print.bytes Rcpp
\end{verbatim}

\begin{verbatim}
## [1] "S3"
\end{verbatim}

Často potřebujete zjistit, jak se jmenují jednotlivé položky objektu. Pokud je objekt v~systému~S3 postaven nad seznamem, což je nejčastější případ, můžete to udělat pomocí funkce \texttt{str()}. Když znáte jméno dané položky, můžete získat její obsah pomocí operátoru~\texttt{\$}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str}\NormalTok{(eva)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 4
##  $ name  : chr "Eve"
##  $ height: num 169
##  $ weight: num 52
##  $ rank  : chr "CEO"
##  - attr(*, "class")= chr [1:2] "manager" "human"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{eva}\SpecialCharTok{$}\NormalTok{height}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 169
\end{verbatim}

Někdy se hodí zjistit, jaké metody má daná třída k~dispozici. K~tomu slouží funkce \texttt{methods()}. Můžete ji použít dvě různými způsoby: 1)~ke zjištění metod, které patří dané generické funkci, a~2)~ke zjištění metod, které jsou k~dispozici pro danou třídu:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{head}\NormalTok{(}\FunctionTok{methods}\NormalTok{(}\StringTok{"print"}\NormalTok{))  }\CommentTok{\# metody generické funkce print() {-}{-} jen prvních 6 metod}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "print.acf"     "print.AES"     "print.anova"   "print.aov"    
## [5] "print.aovlist" "print.ar"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{methods}\NormalTok{(}\AttributeTok{class =} \StringTok{"human"}\NormalTok{)  }\CommentTok{\# metody dostupné pro třídu human}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] bmi   print
## see '?methods' for accessing help and source code
\end{verbatim}

Jména konkrétních metod lze zjistit také pomocí funkce \texttt{apropos()}, když se požádá, aby hledala regulární výraz pro cokoli, co končí ``.třída\_objektu'' (s~regulárními výrazy se seznámíte v~kapitole~\ref{kap:strings}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{apropos}\NormalTok{(}\StringTok{".*}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{.human"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "bmi.human"   "print.human"
\end{verbatim}

Důležité je také najít dokumentaci k~dané metodě. Z~dokumentace ke generické funkci se totiž nemusíte se dozvědět vše, co potřebujete. Pokud chcete nápovědu k~tomu, jak se generická funkce chová pro daný objekt, hledejte dokumentaci k~jeho metodě (bohužel ne všechny balíky dokumentují všechny metody, které implementují):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{?print.summary.lm  }\CommentTok{\# dokumentace k metodě pro tisk summary(m), kde m je objekt vráceny z\textbackslash{} lineární regrese}
\end{Highlighting}
\end{Shaded}

\hypertarget{kap:iterace-nad-vektory}{%
\chapter{Iterace nad prvky atomických vektorů a seznamů}\label{kap:iterace-nad-vektory}}

Často je potřeba provést nějakou operaci s~každým prvkem atomického vektoru, seznamu apod. Většina programovacích jazyků k~tomuto účelu používá cyklus \texttt{for} (viz oddíl~\ref{sec:for}). R~však nabízí dvě lepší řešení. Zaprvé, mnohé funkce jsou v~R vektorizované, tj.~pracují s~vektorem po prvcích a vrátí vektor stejné délky, kde každý prvek je výsledkem aplikace dané funkce na odpovídající prvek původního vektoru. Příkladem takové funkce je např.~funkce \texttt{log()}. Druhou možností je použití funkce \texttt{map()} a jí podobných z~balíku \textbf{purrr}. Tyto funkce berou jako svůj vstup nejen data, ale také jinou (nevektorizovanou) funkci a aplikují ji na každý prvek dat.
Základní R sice poskytuje podobné funkce jako balík \textbf{purrr}, my se však zaměříme na funkce z~balíku \textbf{purrr}, a~to z~několika důvodů: 1)~jejich ovládání je jednodušší, 2)~je kompatibilní s~dalšími funkcemi ve skupině balíků \textbf{tidyverse}, 3)~funkce usnadňují řešení problémů a ladění kódu a 4)~umožňují snadnou paralelizaci pomocí balíku \textbf{furrr}.

V~této kapitole se naučíte

\begin{itemize}
\tightlist
\item
  aplikovat nevektorizované funkce na prvky vektorů
\item
  aplikovat funkce na sloupce tabulek
\item
  zjednodušovat výsledků na atomické vektory
\item
  filtrovat prvky vektorů
\item
  redukovat prvky vektorů
\item
  paralelizovat svůj výpočet
\end{itemize}

Před vlastní prací musíme načíst balík \textbf{purrr}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(purrr)}
\end{Highlighting}
\end{Shaded}

\hypertarget{zuxe1kladnuxed-iterace-nad-prvky-vektorux16f-pomocuxed-map}{%
\section{\texorpdfstring{Základní iterace nad prvky vektorů pomocí \texttt{map()}}{Základní iterace nad prvky vektorů pomocí map()}}\label{zuxe1kladnuxed-iterace-nad-prvky-vektorux16f-pomocuxed-map}}

Nejčastějším případem je, že potřebujeme pomocí nějaké funkce transformovat každý prvek vektoru (atomického nebo seznamu). Základní funkce pro iterace nad vektory je funkce \texttt{map(.x,\ .f,\ ...)}. Její první parametr je vektor~\texttt{.x} (atomický nebo seznam) a druhý parametr je funkce~\texttt{.f}. Funkce \texttt{map()} spustí funkci~\texttt{.f} na každý prvek vektoru~\texttt{.x} a výsledky poskládá do seznamu stejné délky, jako má vektor~\texttt{.x}. Funkci \texttt{map()} si tedy můžete představit jako výrobní linku, kde nad pásovým dopravníkem pracuje robot. Dopravník nejdříve robotovi doručí první prvek~\texttt{.x}, tj.~\texttt{.x{[}{[}1{]}{]}}. Robot na doručeném prvku provede funkci~\texttt{.f()}, tj.~vyhodnotí \texttt{.f(x{[}{[}1{]}{]})} a výsledek uloží zpátky na dopravníkový pás, tj.~jako první prvek nově vytvářeného seznamu. Pak se dopravník posune, robot spustí funkci~\texttt{.f()} na \texttt{.x{[}{[}2{]}{]}} atd., dokud linka nezpracuje všechny prvky vektoru~\texttt{.x}. Fungování linky ukazuje obrázek~\ref{fig:lapply}.

\begin{figure}
\centering
\includegraphics{figs/iteration/map.pdf}
\caption{\label{fig:lapply}Funkce \texttt{map(.x,\ .f)} aplikuje funkci \texttt{.f()} na každý prvek vektoru \texttt{.x} a vrací seznam stejné délky.}
\end{figure}

Všimněte si dvou věcí: 1)~Funkci~\texttt{.f()} předáváme funkci \texttt{map()} jako proměnnou, tj.~bez kulatých závorek. 2)~Funkce \texttt{.f()} od \texttt{map()} vždy dostane jeden prvek vektoru~\texttt{.x} jako svůj první parametr.
Ukážeme si to nejdříve na jednoduchém příkladu. Máme seznam~\texttt{v}, který obsahuje různě dlouhé atomické vektory. Chceme zjistit délku jednotlivých vektorů v~seznamu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{4}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{)  }\CommentTok{\# vytvoří seznam vektorů}
\FunctionTok{map}\NormalTok{(v, length)  }\CommentTok{\# zjistí délku jednotlivých vektorů v seznamu v}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] 1
## 
## [[2]]
## [1] 2
## 
## [[3]]
## [1] 3
## 
## [[4]]
## [1] 4
## 
## [[5]]
## [1] 5
\end{verbatim}

V~dalším příkladu chceme zjistit, jaký datový typ mají jednotlivé sloupce tabulky. Využijeme toho, že tabulky tříd \emph{data.frame} i~\emph{tibble} jsou technicky implementované jako seznamy sloupců a že funkce \texttt{map()} s~nimi takto zachází:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{df }\OtherTok{\textless{}{-}}\NormalTok{ tibble}\SpecialCharTok{::}\FunctionTok{tibble}\NormalTok{(}\AttributeTok{x =} \DecValTok{1}\SpecialCharTok{:}\DecValTok{6}\NormalTok{,  }\CommentTok{\# celá čísla}
                     \AttributeTok{y =} \FunctionTok{c}\NormalTok{(}\FunctionTok{rnorm}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{), }\ConstantTok{NA}\NormalTok{),  }\CommentTok{\# reálná čísla}
                     \AttributeTok{z =} \FunctionTok{c}\NormalTok{(}\ConstantTok{NA}\NormalTok{, letters[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{4}\NormalTok{], }\ConstantTok{NA}\NormalTok{)  }\CommentTok{\# řetězce}
\NormalTok{)}
\NormalTok{df}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 3
##       x      y z    
##   <int>  <dbl> <chr>
## 1     1 -0.388 <NA> 
## 2     2 -0.346 a    
## 3     3 -0.162 b    
## 4     4 -0.817 c    
## 5     5 -0.973 d    
## 6     6 NA     <NA>
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(df, class)  }\CommentTok{\# funkce class() je použita postupně na všechny sloupce df}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $x
## [1] "integer"
## 
## $y
## [1] "numeric"
## 
## $z
## [1] "character"
\end{verbatim}

Výše uvedené příklady ukazují, jak pomocí funkce \texttt{map()} aplikovat na jednotlivé prvky vektoru nějakou existující funkci. Často však chceme na prvky vektoru aplikovat nějaký vlastní výpočet. Pokud jej chceme provést jen na jednom vektoru, nestojí za to vytvářet pojmenovanou funkci, která by zaplevelila naše pracovní prostředí. V~takovém případě můžeme použít anonymní funkci, jak ukazuje následující příklad. V~něm chceme zjistit, kolik každý sloupec tabulky obsahuje hodnot~\texttt{NA}. Druhým parametrem funkce \texttt{map()} je anonymní funkce, tj.~funkce, kterou jsme před tím neuložili do žádné proměnné. Naše anonymní funkce musí brát jako svůj první parametr jeden prvek vektoru, nad kterým se iteruje:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(df, }\ControlFlowTok{function}\NormalTok{(x) }\FunctionTok{sum}\NormalTok{(}\FunctionTok{is.na}\NormalTok{(x)))  }\CommentTok{\# x nabývá vždy hodnotu jednoho sloupce z df}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $x
## [1] 0
## 
## $y
## [1] 1
## 
## $z
## [1] 2
\end{verbatim}

Protože tvorba anonymních funkcí může být protivná, nabízí funkce \texttt{map()} ``zkratku'': místo funkce zadat pravostrannou formuli, kterou \texttt{map()} automaticky převede na funkci. Syntaxe této formule je jednoduchá. Začíná symbolem \texttt{\textasciitilde{}} (vlnkou) za kterou následuje výraz, který se má vyhodnotit. Hodnotu prvku vektoru~\texttt{.x}, který funkce právě vyhodnocuje, zadáme jako \texttt{.} nebo \texttt{.x}. Předchozí výpočet je tedy možné zadat i takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(df, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{sum}\NormalTok{(}\FunctionTok{is.na}\NormalTok{(.)))}
\end{Highlighting}
\end{Shaded}

nebo

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(df, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{sum}\NormalTok{(}\FunctionTok{is.na}\NormalTok{(.x)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $x
## [1] 0
## 
## $y
## [1] 1
## 
## $z
## [1] 2
\end{verbatim}

Funkce \texttt{map()} umožňuje využít i~další¨ zajímavou zkratku, která je užitečná v~případě, že chceme ze seznamu extrahovat prvky, které se nachází na určité pozici nebo mají určité jméno. V~takovém případě zadáme místo funkce \texttt{.f} vektor celých čísel, řetězců nebo jejich kombinaci. Pokud zadáme celé číslo, \texttt{map()} vrátí z~každého prvku vektoru~\texttt{.x} jeho prvek na této pozici; pokud zadáme řetězec, pak jeho prvek s~tímto jménem. Pokud zadáme víc pozic, \texttt{map()} postupuje rekurzivně. Ukažme si to na příkladu. Vytvoříme datovou strukturu, která obsahuje vybrané informace o~hráčích nějaké hry. Všimněte si, že vnější seznam obsahuje dílčí seznamy, které mají stejné pojmenované položky:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{dungeon }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}
  \FunctionTok{list}\NormalTok{(}\AttributeTok{id =} \DecValTok{11}\NormalTok{, }\AttributeTok{name =} \StringTok{"Karel"}\NormalTok{, }\AttributeTok{items =} \FunctionTok{list}\NormalTok{(}\StringTok{"sword"}\NormalTok{, }\StringTok{"key"}\NormalTok{)),}
  \FunctionTok{list}\NormalTok{(}\AttributeTok{id =} \DecValTok{12}\NormalTok{, }\AttributeTok{name =} \StringTok{"Emma"}\NormalTok{, }\AttributeTok{items =} \FunctionTok{list}\NormalTok{(}\StringTok{"mirror"}\NormalTok{, }\StringTok{"potion"}\NormalTok{, }\StringTok{"dagger"}\NormalTok{))}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Nejdříve chceme získat seznam id jednotlivých hráčů. Protože každý vnitřní seznam má \texttt{id} na prvním místě, můžeme jejich seznam získat takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(dungeon, }\DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] 11
## 
## [[2]]
## [1] 12
\end{verbatim}

Pokud chceme získat seznam jmen hráčů, můžeme jej získat buď pomocí pozice (jména jsou ve vnitřních seznamech na druhém místě) výrazem \texttt{map(dungeon,\ 2)}. Můžeme je však extrahovat i~jménem:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(dungeon, }\StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "Karel"
## 
## [[2]]
## [1] "Emma"
\end{verbatim}

Podobně můžeme získat i~seznam artefaktů, které má každý hráč k~dispozici (výsledek je seznamem seznamů):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(dungeon, }\StringTok{"items"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [[1]][[1]]
## [1] "sword"
## 
## [[1]][[2]]
## [1] "key"
## 
## 
## [[2]]
## [[2]][[1]]
## [1] "mirror"
## 
## [[2]][[2]]
## [1] "potion"
## 
## [[2]][[3]]
## [1] "dagger"
\end{verbatim}

Jednotlivé artefakty pak můžeme získat zadáním více pozic, které použijí rekurzivně:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(dungeon, }\FunctionTok{c}\NormalTok{(}\DecValTok{3}\NormalTok{, }\DecValTok{1}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "sword"
## 
## [[2]]
## [1] "mirror"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(dungeon, }\FunctionTok{list}\NormalTok{(}\StringTok{"items"}\NormalTok{, }\DecValTok{1}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "sword"
## 
## [[2]]
## [1] "mirror"
\end{verbatim}

Oba předchozí výrazy vrátili seznam artefaktů, které mají oba hráči na první pozici mezi svými položkami. Všimněte si, že pokud jsme chtěli adresovat \texttt{items} jménem, museli jsme jméno a pozici spojit pomocí seznamu, protože funkce \texttt{c()} by převedla obě pozice na řetězce.

Pokud požádáme o~prvky, které neexistují, dostaneme výsledek \texttt{NULL}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(dungeon, }\FunctionTok{list}\NormalTok{(}\StringTok{"items"}\NormalTok{, }\DecValTok{3}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## NULL
## 
## [[2]]
## [1] "dagger"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(dungeon, }\StringTok{"aloha"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## NULL
## 
## [[2]]
## NULL
\end{verbatim}

Pokud chceme, aby \texttt{map()} v~takovém případě vrátil jinou hodnotu, můžeme ji nastavit pomocí parametru \texttt{.default}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(dungeon, }\FunctionTok{list}\NormalTok{(}\StringTok{"items"}\NormalTok{, }\DecValTok{3}\NormalTok{), }\AttributeTok{.default =} \ConstantTok{NA\_character\_}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] NA
## 
## [[2]]
## [1] "dagger"
\end{verbatim}

Funkci, kterou spouštíme nad jednotlivými prvky vektoru, můžeme předat i~další parametry. Ty se zadají na pozici \texttt{...}, tedy jako třetí a případně další parametry ve funkci \texttt{map()}, jak ukazuje následující příklad. V~něm chceme vytvořit několik vektorů gaussovských náhodných čísel o~různých délkách a průměru~10 a směrodatné odchylce také~10. K tvorbě náhodných vektorů s~normálním rozložením použijeme funkci~\texttt{rnorm()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, rnorm, }\AttributeTok{mean =} \DecValTok{10}\NormalTok{, }\AttributeTok{sd =} \DecValTok{10}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] 2.856743
## 
## [[2]]
## [1]  5.293808 -3.013710
## 
## [[3]]
## [1] 16.67261 33.57374 24.12079
## 
## [[4]]
## [1] -1.634269 17.899576 12.749143 18.897334
## 
## [[5]]
## [1]  6.610532  1.856126 -1.705727  5.521963  6.992908
\end{verbatim}

Funkce \texttt{map()} v~našem příkladu iteruje nad vektorem \texttt{1:5}, jehož jednotlivé prvky se předají funkci \texttt{rnorm()} jako její první parametr, tj.~jako délka vytvářeného vektoru. Střední hodnotu a směrodatnou odchylku vytvářených náhodných vektorů jsme ve funkci \texttt{rnorm()} nastavili pomocí pojmenovaných parametrů \texttt{mean} a \texttt{sd}. Funkce \texttt{map()} tedy postupně vyhodnocovala výrazy \texttt{rnorm(1,\ mean\ =\ 10,\ sd\ =\ 10}), \texttt{rnorm(2,\ mean\ =\ 10,\ sd\ =\ 10)} atd.

Jak jsme viděli, funkce \texttt{map()} vrací svůj výsledek jako seznam. To je často užitečné, protože seznamy umožňují v~jedné datové struktuře skladovat hodnoty různých délek, datových typů a struktur. Někdy však funkce \texttt{.f()} vrací na našich datech vždy atomický vektor stejného datového typu a délky~1. V~tom případě můžeme chtít výsledek zjednodušit na atomický vektor. K~tomu slouží funkce \texttt{map\_lgl()}, \texttt{map\_int()}, \texttt{map\_dbl()} a \texttt{map\_chr()}, které mají stejné vstupní parametry jako funkce \texttt{map()}, ale svůj výsledek zjednoduší na logický, celočíselný nebo reálný vektor nebo vektor řetězců.

Ukážeme si to nejdříve na příkladu, který jsme viděli výše: Chceme zjistit počet chybějících hodnot v~jednotlivých sloupcích tabulky, výsledek však chceme mít uložený v~atomickém vektoru (názvy hodnot odpovídají jménům sloupců tabulky):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_int}\NormalTok{(df, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{sum}\NormalTok{(}\FunctionTok{is.na}\NormalTok{(.)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## x y z 
## 0 1 2
\end{verbatim}

Pokud by výsledek nebylo možné zjednodušit na daný datový typ, volání funkce by skončilo chybou, jak ukazuje následující příklad:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_int}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, log)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: Can't coerce element 1 from a double to a integer
\end{verbatim}

Podívejme se nyní na komplexnější ukázku použití funkce \texttt{map()} převzatou z~její dokumentace. Řekněme, že chceme zjistit, jak silně závisí spotřeba aut na jejich váze~-- ve smyslu, kolik procent rozptylu spotřeby vysvětlí váha aut, a~to zvlášť pro každý počet válců. K~tomu použijeme standardní dataset \texttt{mtcars} (třída \emph{data.frame}). Rozdělíme jej pomocí funkce \texttt{split(x,\ f,\ drop\ =\ FALSE,\ ...)}. Funkce \texttt{split()} bere na vstupu atomický vektor, seznam nebo tabulku \texttt{x} a vektor \texttt{f}, který určí rozdělení \texttt{x} do skupin. Funkce vrací seznam, jehož jednotlivé prvky obsahují části proměnné \texttt{x}~-- každý prvek obsahuje část~\texttt{x}, pro kterou má \texttt{f} stejnou hodnotu. Následující kód tedy rozdělí tabulku \texttt{mtcars} na tři tabulky uložené v~jednom pojmenovaném seznamu \texttt{cars}. Každá z~těchto dílčích tabulek bude obsahovat jen pozorování se stejným počtem válců: první tabulka~4, druhá~6 a třetí 8~válců:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{cars }\OtherTok{\textless{}{-}} \FunctionTok{split}\NormalTok{(mtcars, mtcars}\SpecialCharTok{$}\NormalTok{cyl)}
\end{Highlighting}
\end{Shaded}

Na každé této tabulce zvlášť odhadneme lineární model, který vysvětluje spotřebu (\texttt{mpg}, počet mil, který vůz ujede na galon paliva) pomocí váhy vozidla (\texttt{wt}) a úrovňové konstanty. Vlastní odhad provede funkce \texttt{lm()}. Její první parametr je formule \texttt{mpg\ \textasciitilde{}\ wt}, která popisuje odhadovanou rovnici (zde \(\textrm{mpg}_i = b_0 + b_1 \textrm{wt}_i + \epsilon_i\)). Druhý parametr jsou data, na který se má model odhadnout. Pomocí funkce \texttt{map()} aplikujeme funkci \texttt{lm()} na každý prvek seznamu \texttt{cars}, tj.~na tři tabulky, které jsme vytvořili v~předchozím kroku:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{estimates }\OtherTok{\textless{}{-}} \FunctionTok{map}\NormalTok{(cars, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{lm}\NormalTok{(mpg }\SpecialCharTok{\textasciitilde{}}\NormalTok{ wt, }\AttributeTok{data =}\NormalTok{ .))}
\end{Highlighting}
\end{Shaded}

Výsledkem je seznam, který obsahuje opět tři prvky: objekty, které popisují odhad modelu na třech částech rozdělené tabulky. Nás z~nich zajímá jediná hodnota: koeficient determinace~\(R^2\), který říká, kolik procent rozptylu vysvětlované veličiny model vysvětlil. Ten získáme jako slot \texttt{r.squared} objektu, který vrací funkce \texttt{summary()}. Výpočet opět musíme spustit pro všechny prvky seznamu \texttt{estimates}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s }\OtherTok{\textless{}{-}} \FunctionTok{map}\NormalTok{(estimates, summary)}
\FunctionTok{map\_dbl}\NormalTok{(s, }\StringTok{"r.squared"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##         4         6         8 
## 0.5086326 0.4645102 0.4229655
\end{verbatim}

Vidíme, že sama váha vysvětluje velkou část spotřeby. Celý výpočet můžeme zapsat kompaktněji pomocí operátoru \texttt{\%\textgreater{}\%}, který předá výsledek předchozího výpočtu (svou levou stranu) jako první parametr do funkce v~následném výpočtu (na své pravé straně), viz oddíl~\ref{sec:pipes}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{mtcars }\SpecialCharTok{\%\textgreater{}\%}
  \FunctionTok{split}\NormalTok{(.}\SpecialCharTok{$}\NormalTok{cyl) }\SpecialCharTok{\%\textgreater{}\%}
  \FunctionTok{map}\NormalTok{(}\SpecialCharTok{\textasciitilde{}} \FunctionTok{lm}\NormalTok{(mpg }\SpecialCharTok{\textasciitilde{}}\NormalTok{ wt, }\AttributeTok{data =}\NormalTok{ .x)) }\SpecialCharTok{\%\textgreater{}\%}
  \FunctionTok{map}\NormalTok{(summary) }\SpecialCharTok{\%\textgreater{}\%}
  \FunctionTok{map\_dbl}\NormalTok{(}\StringTok{"r.squared"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##         4         6         8 
## 0.5086326 0.4645102 0.4229655
\end{verbatim}

Více se o~ekonometrii dozvíte v~kapitole~\ref{kap:ekonometrie}.

Funkce \texttt{map\_dfc(x,\ f)} a \texttt{map\_dfr(x,\ f)} fungují podobně jako \texttt{map()}, ale výsledek transformují na tabulku po sloupcích a řádcích respektive. Detaily najdete v~dokumentaci. Zde si ukážeme jen několik příkladů. Řekněme, že máme pojmenovaný seznam několika atomických vektorů. Chceme je nějak transformovat (např.~spočítat jejich druhou mocninu) a výsledky složit vedle sebe jako sloupce tabulky:

Podobně můžeme rozdělit tabulku pomocí funkce \texttt{split()} na části, které uložíme do seznamu. Potom, co na každé části tabulky provedeme nějaké operace, můžeme výsledek opět spojit pomocí \texttt{map\_df()}:

Nakonec si ukážeme poněkud složitější příklad. Řekněme, že máme seznam atomických vektorů~\texttt{s} (zde si jej nasimulujeme) a pro každý vektor v~seznamu chceme zjistit základní popisné statistiky. Pro jeden vektor nám je spočítá funkce \texttt{summary()}. My však chceme tyto statistiky spočítat pro každý jednotlivý vektor a uložit je do tabulky, kde bude každý řádek odpovídat jednomu původnímu vektoru a sloupec jedné statistice. To můžeme udělat takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s }\OtherTok{\textless{}{-}} \FunctionTok{replicate}\NormalTok{(}\DecValTok{5}\NormalTok{, }\FunctionTok{rnorm}\NormalTok{(}\DecValTok{100}\NormalTok{), }\AttributeTok{simplify =} \ConstantTok{FALSE}\NormalTok{)}
\FunctionTok{map\_dfr}\NormalTok{(s, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{set\_names}\NormalTok{(}\FunctionTok{as.list}\NormalTok{(}\FunctionTok{summary}\NormalTok{(.)), }\AttributeTok{nm =} \FunctionTok{names}\NormalTok{(}\FunctionTok{summary}\NormalTok{(.))))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 6
##    Min. `1st Qu.`   Median    Mean `3rd Qu.`  Max.
##   <dbl>     <dbl>    <dbl>   <dbl>     <dbl> <dbl>
## 1 -2.00    -0.812  0.00721 -0.167      0.543  2.06
## 2 -1.94    -0.596  0.0553   0.0820     0.792  3.08
## 3 -2.05    -0.777 -0.200   -0.142      0.571  1.90
## 4 -2.07    -0.588  0.00199  0.0654     0.683  2.46
## 5 -2.51    -0.521  0.158    0.110      0.842  2.52
\end{verbatim}

Výraz \texttt{as.list(summary(.)} spočítá statistiky pro právě zpracovávaný prvek a převede je na seznam. Funkce \texttt{set\_names()} pojmenuje prvky seznamu podle jednotlivých prvků objektu, který vrací funkce \texttt{summary()}. Funkce \texttt{map\_dfr()} tak pro každý vektor v~seznamu~\texttt{s} získá pojmenovaný seznam statistik. Ten převede na tabulku a jednotlivé tabulky spojí.

Někdy nechceme transformovat všechny, ale jen vybrané prvky nějakého vektoru. K~tomu slouží funkce \texttt{map\_if(.x,\ .p,\ .f,\ ...,\ .else\ =\ NULL)} a \texttt{map\_at(.x,\ .at,\ .f,\ ...)}. Tyto funkce fungují podobně jako \texttt{map()}, liší se však tím, na které prvky se použije funkce~\texttt{.f}: \texttt{map()} ji použije všechny prvky vektoru~\texttt{.x}, \texttt{map\_at()} pouze na vyjmenované prvky a \texttt{map\_if()} pouze na prvky, které splňují nějakou podmínku.
Funkce \texttt{map\_if()} má stejné parametry jako \texttt{map()} plus dva navíc: \texttt{.p} je \emph{predikátová funkce} (tj.~funkce, která vrací logické hodnoty), která určí, které prvky se budou transformovat; funkce \texttt{.f} se použije na ty prvky \texttt{.x}, kde \texttt{.p()} vrací \texttt{TRUE}. Pokud je zadaná i~funkce \texttt{.else}, pak se použije na ty prvky \texttt{.x}, kde \texttt{.p()} vrací \texttt{FALSE}. Pokud parametr \texttt{.else} nezadáme, pak se tyto prvky ponechají beze změny.

Ukažme si to na příkladu. Řekněme, že máme seznam, který obsahuje vektory čísel a řetězců. Numerické vektory chceme standardizovat tak, že od nich odečteme jejich střední hodnotu, zatímco řetězce chceme ponechat beze změny. To můžeme snadno udělat takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, }\FunctionTok{rnorm}\NormalTok{(}\DecValTok{5}\NormalTok{), LETTERS[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{])  }\CommentTok{\# tvorba seznamu}
\NormalTok{v}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] 1 2 3 4 5
## 
## [[2]]
## [1]  0.3786097  0.2109682 -0.2105890 -1.8059577  1.1888325
## 
## [[3]]
## [1] "A" "B" "C" "D" "E"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_if}\NormalTok{(v, is.numeric, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}} \FunctionTok{mean}\NormalTok{(.))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] -2 -1  0  1  2
## 
## [[2]]
## [1]  0.4262370  0.2585955 -0.1629617 -1.7583305  1.2364597
## 
## [[3]]
## [1] "A" "B" "C" "D" "E"
\end{verbatim}

Pokud bychom chtěli v~jednom kroku zároveň odečíst střední hodnotu od numerických vektorů a řetězce převést na malá písmena, mohli bychom to provést takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_if}\NormalTok{(v, is.numeric, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}} \FunctionTok{mean}\NormalTok{(.), }\AttributeTok{.else =}\NormalTok{ stringr}\SpecialCharTok{::}\NormalTok{str\_to\_lower)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] -2 -1  0  1  2
## 
## [[2]]
## [1]  0.4262370  0.2585955 -0.1629617 -1.7583305  1.2364597
## 
## [[3]]
## [1] "a" "b" "c" "d" "e"
\end{verbatim}

Protože tabulky jsou v~R implementované jako seznam sloupců, můžeme totéž provést i~s~tabulkou:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{df  }\CommentTok{\# původní tabulka}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 3
##       x      y z    
##   <int>  <dbl> <chr>
## 1     1 -0.388 <NA> 
## 2     2 -0.346 a    
## 3     3 -0.162 b    
## 4     4 -0.817 c    
## 5     5 -0.973 d    
## 6     6 NA     <NA>
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_if}\NormalTok{(df, is.numeric, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}} \FunctionTok{mean}\NormalTok{(., }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $x
## [1] -2.5 -1.5 -0.5  0.5  1.5  2.5
## 
## $y
## [1]  0.1489125  0.1913107  0.3754535 -0.2800433 -0.4356335         NA
## 
## $z
## [1] NA  "a" "b" "c" "d" NA
\end{verbatim}

Funkce \texttt{map\_at()} funguje podobně, ale které prvky se mají transformovat, musíme zadat jejich jménem nebo pozicí. Stejně jako u~výběru prvků vektoru je možné používat kladné i záporné vektory pozic: kladné určují, které se mají transformovat, záporné říkají, které prvky se nemají transformovat. Odečíst střední hodnoty od numerických vektorů tedy můžeme i~takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_at}\NormalTok{(df, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}} \FunctionTok{mean}\NormalTok{(., }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $x
## [1] -2.5 -1.5 -0.5  0.5  1.5  2.5
## 
## $y
## [1]  0.1489125  0.1913107  0.3754535 -0.2800433 -0.4356335         NA
## 
## $z
## [1] NA  "a" "b" "c" "d" NA
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_at}\NormalTok{(df, }\SpecialCharTok{{-}}\DecValTok{3}\NormalTok{, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}} \FunctionTok{mean}\NormalTok{(., }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{))  }\CommentTok{\# totéž}
\FunctionTok{map\_at}\NormalTok{(df, }\FunctionTok{c}\NormalTok{(}\StringTok{"x"}\NormalTok{, }\StringTok{"y"}\NormalTok{), }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}} \FunctionTok{mean}\NormalTok{(., }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{))  }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

Funkce \texttt{map()} a její odvozeniny vracejí vždy konkrétní objekt: \texttt{map()} vrací seznam, \texttt{map\_lgl()} vrací logický vektor apod. Pokud potřebujeme, aby funkce vrátila stejnou datovou strukturu, jako dostala na vstupu, můžete místo nich použít funkci \texttt{modify(.x,\ .f,\ ...)} a její odvozeniny, \texttt{modify\_if(.x,\ .p,\ .f,\ ...,\ .else\ =\ NULL)}, \texttt{modify\_at(.x,\ .at,\ .f,\ ...)}. Tyto funkce se používají stejně jako odpovídající funkce z~rodiny \texttt{map()}. Srovnejte rozdíl:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{+}\NormalTok{ 2L)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] 3
## 
## [[2]]
## [1] 4
## 
## [[3]]
## [1] 5
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{modify}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{+}\NormalTok{ 2L)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3 4 5
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_if}\NormalTok{(df, is.numeric, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{\^{}} \DecValTok{2}\NormalTok{) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{str}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 3
##  $ x: num [1:6] 1 4 9 16 25 36
##  $ y: num [1:6] 0.1506 0.1195 0.0261 0.6676 0.9461 ...
##  $ z: chr [1:6] NA "a" "b" "c" ...
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{modify\_if}\NormalTok{(df, is.numeric, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{\^{}} \DecValTok{2}\NormalTok{) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{str}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## tibble [6 x 3] (S3: tbl_df/tbl/data.frame)
##  $ x: num [1:6] 1 4 9 16 25 36
##  $ y: num [1:6] 0.1506 0.1195 0.0261 0.6676 0.9461 ...
##  $ z: chr [1:6] NA "a" "b" "c" ...
\end{verbatim}

Funkce \texttt{map()} aplikovaná na celočíselný vektor vrací seznam, zatímco funkce \texttt{modify()} vrací celočíselný vektor. (Zkuste, co se stane, pokud se pokusíte místo \texttt{2L} přičíst \texttt{2}.) Podobně funkce \texttt{map\_if()} aplikovaná na tabulku vrací seznam, zatímco funkce \texttt{modify\_if()} vrací tabulku stejné třídy, jako je její vstup.

Funkce typu \texttt{modify()} se tedy hodí např.~pro transformace vybraných sloupců tabulek. Řekněme, že máme tabulku s~příjmy a výdaji z~hyperinflační ekonomiky. Pokud by došlo k~měnové reformě, potřebujeme u~všech numerických sloupců škrtnout tři nuly. To můžeme provést např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{df }\OtherTok{\textless{}{-}}\NormalTok{ tibble}\SpecialCharTok{::}\FunctionTok{tibble}\NormalTok{(}\AttributeTok{names =} \FunctionTok{c}\NormalTok{(}\StringTok{"Adam"}\NormalTok{, }\StringTok{"Bětka"}\NormalTok{, }\StringTok{"Cyril"}\NormalTok{),}
                     \AttributeTok{income =} \FunctionTok{c}\NormalTok{(}\FloatTok{1.3}\NormalTok{, }\FloatTok{1.5}\NormalTok{, }\FloatTok{1.7}\NormalTok{) }\SpecialCharTok{*} \FloatTok{1e6}\NormalTok{,}
                     \AttributeTok{rent =} \FunctionTok{c}\NormalTok{(}\DecValTok{500}\NormalTok{, }\DecValTok{450}\NormalTok{, }\DecValTok{580}\NormalTok{) }\SpecialCharTok{*} \FloatTok{1e3}\NormalTok{,}
                     \AttributeTok{loan =} \FunctionTok{c}\NormalTok{(}\DecValTok{0}\NormalTok{, }\DecValTok{250}\NormalTok{, }\DecValTok{390}\NormalTok{) }\SpecialCharTok{*} \FloatTok{1e9}\NormalTok{)}
\NormalTok{df }\OtherTok{\textless{}{-}} \FunctionTok{modify\_if}\NormalTok{(df, is.numeric, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{/} \DecValTok{1000}\NormalTok{)}
\NormalTok{df}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 4
##   names income  rent      loan
##   <chr>  <dbl> <dbl>     <dbl>
## 1 Adam    1300   500         0
## 2 Bětka   1500   450 250000000
## 3 Cyril   1700   580 390000000
\end{verbatim}

V~kapitole~\ref{kap:dplyr} se však naučíte jiné funkce specializované pro práci s~tabulkami z~balíku \textbf{dplyr}.

Někdy nechceme při iterování nad prvky vektoru vracet hodnoty, nýbrž provést nějaké jiné operace, které iterovaná funkce provádí jako své vedlejší účinky. K~tomuto účelu slouží funkce \texttt{walk(x,\ f,\ ...)}. Její syntaxe je stejná jako u~funkce \texttt{map()}. Řekněme, že chceme vypsat všechny prvky nějakého vektoru. To můžeme pomocí funkce \texttt{walk()} udělat např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\DecValTok{1}\NormalTok{, }\StringTok{"a"}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\FunctionTok{walk}\NormalTok{(v, print)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
## [1] "a"
## [1] 3
\end{verbatim}

Funkce \texttt{walk()} tiše vrací vektor~\texttt{v}, takže je možné i~zařadit i~do proudu ``trubek'' (viz~oddíl~\ref{sec:pipes}):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{walk}\NormalTok{(print) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{map\_int}\NormalTok{(length)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
## [1] "a"
## [1] 3
\end{verbatim}

\begin{verbatim}
## [1] 1 1 1
\end{verbatim}

To je užitečné např.~při ladění dlouhého výrazu s~mnoha ``trubkami'', protože do proudu můžeme zařadit výpis nebo vykreslení výsledků bez toho, abychom museli ``potrubí'' narušit.

\hypertarget{iterace-nad-vuxedce-vektory-souux10dasnux11b}{%
\section{Iterace nad více vektory současně}\label{iterace-nad-vuxedce-vektory-souux10dasnux11b}}

Někdy potřebujeme iterovat nad více vektory současně. Můžeme např.~chtít vytvořit seznam vektorů tisíce gaussovských náhodných čísel, kde každý vektor bude mít jinou střední hodnotu a směrodatnou odchylku. Pomocí funkce \texttt{map()} bychom to mohli udělat např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{m }\OtherTok{\textless{}{-}} \DecValTok{0}\SpecialCharTok{:}\DecValTok{5}  \CommentTok{\# požadované střední hodnoty}
\NormalTok{std }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{6}  \CommentTok{\# požadované směrodatné odchylky}
\NormalTok{z }\OtherTok{\textless{}{-}} \FunctionTok{map}\NormalTok{(}\FunctionTok{seq\_along}\NormalTok{(m), }\SpecialCharTok{\textasciitilde{}} \FunctionTok{rnorm}\NormalTok{(}\DecValTok{1000}\NormalTok{, }\AttributeTok{mean =}\NormalTok{ m[.], }\AttributeTok{sd =}\NormalTok{ std[.]))}
\FunctionTok{str}\NormalTok{(z)  }\CommentTok{\# struktura výsledného seznamu}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 6
##  $ : num [1:1000] 1.286 1.947 0.282 -1.916 0.552 ...
##  $ : num [1:1000] 0.498 1.331 0.215 0.974 1.362 ...
##  $ : num [1:1000] 5.16 4.5 2.75 4.48 4.44 ...
##  $ : num [1:1000] 6.22 -2.87 4.68 2.25 2.38 ...
##  $ : num [1:1000] 1.53 2.02 11.25 5.62 -0.82 ...
##  $ : num [1:1000] -2.52 -7.56 2.77 9.28 21.88 ...
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{z }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{map\_dbl}\NormalTok{(mean)  }\CommentTok{\# střední hodnoty jednotlivých vektorů v seznamu}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 0.04788534 1.02284087 1.84724650 3.16833943 3.94284386 4.82886813
\end{verbatim}

Balík \textbf{purrr} však pro tyto účely nabízí příjemnější funkce. Pro iterace nad dvěma vektory zavádí funkci \texttt{map2(.x,\ .y,\ .f,\ ...)} a odpovídající zjednodušující funkce \texttt{map2\_lgl()}, \texttt{map2\_int()} atd. Všechny tyto funkce berou vektory~\texttt{.x} a \texttt{.y}, nad kterými mají iterovat, jako své první dva parametry. Třetí parametr je jméno iterované funkce (musí brát aspoň dva parametry). Případné další parametry jsou předány funkci~\texttt{.f()} jako její třetí a další parametr. Postup výpočtu ukazuje obrázek~\ref{fig:map2}.

\begin{figure}
\centering
\includegraphics{figs/iteration/map2.pdf}
\caption{\label{fig:map2}Funkce \texttt{map2(.x,\ .y,\ .f)} aplikuje funkci \texttt{.f()} na odpovídající prvky vektorů \texttt{.x} a \texttt{.y} a vrací seznam stejné délky.}
\end{figure}

Pokud chceme stejně jako výše vytvořit pět náhodných gaussovsky rozdělených vektorů se středními hodnotami 0, 1 atd. a směrodatnými odchylkami 1, 2 atd., můžeme je sestavit takto (všimněte si, že další parametry, zde délka vytvářených vektorů, musejí být uvedeny až za jménem iterované funkce):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{z }\OtherTok{\textless{}{-}} \FunctionTok{map2}\NormalTok{(}\DecValTok{0}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{6}\NormalTok{, rnorm, }\AttributeTok{n =} \DecValTok{1000}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Funkce opět umožňuje zadat místo funkce \texttt{.f()} pravostrannou formuli, kterou na funkci sama převede. Zpracovávaný prvek vektoru \texttt{.x} v~zadáme jako \texttt{.x}, prvek vektoru \texttt{.y} jako \texttt{.y}. Řekněme tedy, že chce vytvořit tisíc vektorů náhodných čísel s~gaussovským rozdělením a různými středními hodnotami a směrodatnými odchylkami, a~z~těchto vektorů spočítat jejich střední hodnotu. To můžeme udělat takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map2\_dbl}\NormalTok{(}\DecValTok{0}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{6}\NormalTok{, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{mean}\NormalTok{(}\FunctionTok{rnorm}\NormalTok{(}\AttributeTok{n =} \DecValTok{1000}\NormalTok{, }\AttributeTok{mean =}\NormalTok{ .x, }\AttributeTok{sd =}\NormalTok{ .y)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 0.005434992 0.992084097 1.801101818 3.170260680 3.794749492 5.114539769
\end{verbatim}

Pro iterace nad větším počtem vektorů nabízí \textbf{purrr} funkci \texttt{pmap(.l,\ .f,\ ...)} a její zjednodušující varianty \texttt{pmap\_lgl()} atd., kde \texttt{.l} je buď seznam nebo tabulka vektorů, nad kterými se má iterovat, a~\texttt{.f} je buď funkce, která bere příslušný počet parametrů, nebo pravostranná formule, kterou \texttt{pmap()} převede na funkci.
Pokud je \texttt{.f} funkce a jednotlivé vektory v \texttt{.l} nejsou pojmenované, pak se předávají do \texttt{.f} podle svého pořadí. Pokud jsou pojmenované, pak se předávají jménem, takže na jejich fyzickém pořadí v \texttt{.l} nezáleží.

Řekněme, že chceme opět vytvořit seznam náhodných výběrů z~gaussovského rozdělení. Každý výběr bude mít různý počet prvků, různou střední hodnotu a různou směrodatnou odchylku. Pokud seznam parametrů nepojmenujeme, musíme mít jednotlivé parametry v~seznamu v~tom pořadí, v~jakém je očekává funkce \texttt{rnorm()}, která vygeneruje náhodná čísla:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{n }\OtherTok{\textless{}{-}}\NormalTok{ (}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{) }\SpecialCharTok{*} \DecValTok{100}  \CommentTok{\# počet pozorování je 100, 200, ..., 500}
\NormalTok{mu }\OtherTok{\textless{}{-}} \DecValTok{0}\SpecialCharTok{:}\DecValTok{4}  \CommentTok{\# střední hodnota je 0, 1, ..., 4}
\NormalTok{sd }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{5}  \CommentTok{\# směrodatná odchylka je 1, 2, ..., 5}
\NormalTok{pars }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(n, mu, sd)  }\CommentTok{\# nepojmenovaný seznam parametrů v pořadí}
\NormalTok{z }\OtherTok{\textless{}{-}} \FunctionTok{pmap}\NormalTok{(pars, rnorm)}
\FunctionTok{str}\NormalTok{(z)  }\CommentTok{\# struktura výsledku}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 5
##  $ : num [1:100] 0.723 -0.286 -0.435 -0.227 -0.493 ...
##  $ : num [1:200] -0.025 -0.438 -1.316 2.355 -0.772 ...
##  $ : num [1:300] 3.59 5.35 5.22 3.23 4.22 ...
##  $ : num [1:400] -1.31 13.37 6.83 7.29 5.07 ...
##  $ : num [1:500] 2.09 2.744 0.384 -1.422 1.831 ...
\end{verbatim}

Pokud jednotlivé parametry v~seznamu pojmenujeme, na jejich pořadí nezáleží, protože se předají jménem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{pars }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\AttributeTok{sd =}\NormalTok{ sd, }\AttributeTok{mean =}\NormalTok{ mu, }\AttributeTok{n =}\NormalTok{ n)  }\CommentTok{\# pojmenovaný seznam parametrů}
\NormalTok{z }\OtherTok{\textless{}{-}} \FunctionTok{pmap}\NormalTok{(pars, rnorm)}
\FunctionTok{str}\NormalTok{(z)  }\CommentTok{\# struktura výsledku}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 5
##  $ : num [1:100] -0.781 -0.184 1.384 0.913 1.793 ...
##  $ : num [1:200] -0.176 1.184 1.479 -0.553 3.399 ...
##  $ : num [1:300] -4.55 1 1.75 1.08 4.5 ...
##  $ : num [1:400] 4.02 7.34 3.25 2.54 -0.32 ...
##  $ : num [1:500] 8.59 11.09 4.4 4.48 1.76 ...
\end{verbatim}

Pohodlnější je však zadat parametry jako tabulku:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{pars }\OtherTok{\textless{}{-}}\NormalTok{ tibble}\SpecialCharTok{::}\FunctionTok{tibble}\NormalTok{(}\AttributeTok{sd =}\NormalTok{ sd, }\AttributeTok{mean =}\NormalTok{ mu, }\AttributeTok{n =}\NormalTok{ n)}
\NormalTok{z }\OtherTok{\textless{}{-}} \FunctionTok{pmap}\NormalTok{(pars, rnorm)}
\FunctionTok{str}\NormalTok{(z)  }\CommentTok{\# struktura výsledku}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 5
##  $ : num [1:100] -0.997 -1.41 0.802 0.804 0.54 ...
##  $ : num [1:200] 5.909 -0.586 2.426 0.242 -1.003 ...
##  $ : num [1:300] 7.39 2.37 1.37 8.19 5.25 ...
##  $ : num [1:400] 0.357 -1.391 4.488 6.863 1.698 ...
##  $ : num [1:500] 8.63 7.09 8.8 5.86 7.85 ...
\end{verbatim}

Pokud místo funkce zadáme \texttt{.f} jako pravostrannou formuli, pak první vektor v~seznamu nebo tabulce označíme jako \texttt{..1}, druhý jako \texttt{..2} atd.:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{z }\OtherTok{\textless{}{-}} \FunctionTok{pmap}\NormalTok{(pars, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{rnorm}\NormalTok{(}\AttributeTok{n =}\NormalTok{ ..}\DecValTok{3}\NormalTok{, }\AttributeTok{mean =}\NormalTok{ ..}\DecValTok{2}\NormalTok{, }\AttributeTok{sd =}\NormalTok{ ..}\DecValTok{1}\NormalTok{))}
\FunctionTok{str}\NormalTok{(z)  }\CommentTok{\# struktura výsledku}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 5
##  $ : num [1:100] 2.4445 -0.8054 0.0847 -0.158 1.0148 ...
##  $ : num [1:200] 1.528 -0.788 -1.128 2.227 -0.249 ...
##  $ : num [1:300] 1.7792 -2.9792 1.4489 -0.0395 -1.9658 ...
##  $ : num [1:400] 3.712 0.826 -3.8 3.241 0.963 ...
##  $ : num [1:500] 0.5783 5.1355 0.0121 -1.5518 3.4914 ...
\end{verbatim}

Balík \textbf{purrr} implementuje i~funkci \texttt{modify2()} a funkce \texttt{walk2()} a \texttt{pwalk()}, které umožňují iterovat vedlejší efekty nad více vektory.

\hypertarget{filtrace-a-detekce-prvkux16f-vektorux16f}{%
\section{Filtrace a detekce prvků vektorů}\label{filtrace-a-detekce-prvkux16f-vektorux16f}}

Balík \textbf{purrr} implementuje i~několik funkcí určených k~filtraci hodnot vektorů.
Funkce \texttt{keep(.x,\ .p,\ ...)} vrací ty prvky vektoru~\texttt{.x}, pro které predikátová funkce~\texttt{.p()} vrací hodnotu \texttt{TRUE}.
Naopak funkce \texttt{discard(.x,\ .p,\ ...)} vrací ty prvky vektoru~\texttt{.x}, pro které predikátová funkce~\texttt{.p()} vrací hodnotu \texttt{FALSE}, tj.~zahazuje prvky, pro které podmínka platí.
Funkce \texttt{head\_while(.x,\ .p,\ ...)} a \texttt{tail\_while(.x,\ .p,\ ...)} vrací všechny prvky od začátku nebo od konce, pro které funkce~\texttt{.p()} souvisle vrací hodnotu~\texttt{TRUE}. Ve všech těchto funkcích nemusí být \texttt{.p} funkce: může to být i~logický vektor stejné délky jako~\texttt{.x} nebo pravostranná formule, která vrací logickou hodnotu. Jejich použití ukazuje následující příklad:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{10}
\NormalTok{is.odd }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x) x }\SpecialCharTok{\%\%} \DecValTok{2} \SpecialCharTok{!=} \DecValTok{0}  \CommentTok{\# vrací TRUE, když je číslo liché}
\FunctionTok{keep}\NormalTok{(v, is.odd)  }\CommentTok{\# výběr lichých hodnot z vektoru v}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 3 5 7 9
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{keep}\NormalTok{(v, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{\%\%} \DecValTok{2} \SpecialCharTok{!=} \DecValTok{0}\NormalTok{)  }\CommentTok{\# totéž pomocí pravostranné formule}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 3 5 7 9
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{discard}\NormalTok{(v, is.odd)  }\CommentTok{\# vrácení vektoru v bez lichých hodnot}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  2  4  6  8 10
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{head\_while}\NormalTok{(v, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{\textless{}} \DecValTok{5}\NormalTok{)  }\CommentTok{\# vrácení prvních hodnot menších než 5}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3 4
\end{verbatim}

Funkce \texttt{compact(.x,\ .p\ =\ identity)} umožňuje ze seznamu vypustit ty prvky, které mají buď hodnotu \texttt{NULL} nebo nulovou délku.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{compact}\NormalTok{(}\FunctionTok{list}\NormalTok{(}\AttributeTok{a =} \DecValTok{1}\NormalTok{, }\AttributeTok{b =} \DecValTok{2}\NormalTok{, }\AttributeTok{c =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{d =} \DecValTok{4}\NormalTok{, }\AttributeTok{e =} \FunctionTok{numeric}\NormalTok{(}\DecValTok{0}\NormalTok{)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $a
## [1] 1
## 
## $b
## [1] 2
## 
## $d
## [1] 4
\end{verbatim}

Parametr \texttt{.p} umožňuje zadat funkci nebo formuli. Pokud tato funkce vrátí \texttt{NULL} nebo prázdný vektor, pak funkce \texttt{compact()} vynechá odpovídající prvek. Zbývající hodnoty však nejsou funkcí \texttt{.p} nijak transformované. Použití ukazuje triviální příklad:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{compact}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, }\AttributeTok{.p =} \SpecialCharTok{\textasciitilde{}}\NormalTok{ .[. }\SpecialCharTok{\textless{}} \DecValTok{4}\NormalTok{])  }\CommentTok{\# zachová pouze prvky menší než 4}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 3
\end{verbatim}

Funkce \texttt{detect(.x,\ .f,\ ...,\ .dir\ =\ c("forward",\ "backward"),\ .default\ =\ NULL)} vrací první položku vektoru~\texttt{.x}, pro kterou vrací \texttt{.f} hodnotu~\texttt{TRUE}. Funkce \texttt{detect\_index(.x,\ .f,\ ...,\ .dir\ =\ c("forward",\ "backward"))} vrací index této položky. Stejně jako výše může \texttt{.f} být funkce nebo pravostranná formule, která vrací logickou hodnotu.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{detect}\NormalTok{(v, is.odd)  }\CommentTok{\# první lichá hodnota ve vektoru v}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{detect}\NormalTok{(v, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{\textgreater{}} \DecValTok{1}\NormalTok{)  }\CommentTok{\# první hodnota větší než 1}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{detect\_index}\NormalTok{(v, is.odd)  }\CommentTok{\# index prvního lichého prvku vektoru v}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{detect\_index}\NormalTok{(v, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{\textgreater{}} \DecValTok{1}\NormalTok{)  }\CommentTok{\# index prvního prvku většího než 1}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 2
\end{verbatim}

Dva zbývající parametry určují směr, odkud se budou hodnoty hledat (parametr \texttt{.dir}, implicitně zepředu), a~jaká hodnota se vrátí, pokud žádný prvek vektoru nesplňuje zadaný predikát (parametr \texttt{.default}).

Funkce \texttt{every(.x,\ .p,\ ...)} a \texttt{some(.x,\ .p,\ ...)} zobecňují logické funkce \texttt{all()} a \texttt{any()}. \texttt{every()} vrací \texttt{TRUE}, pokud zadaná predikátová funkce \texttt{.p} vrací pro každý prvek vektoru \texttt{.x} hodnotu \texttt{TRUE}; funkce \texttt{some()} vrací \texttt{TRUE}, pokud \texttt{.f} vrací \texttt{TRUE} aspoň pro jeden prvek \texttt{.x}. Pomocí těchto funkcí můžeme např.~otestovat, zda tabulka \texttt{df} obsahuje aspoň jeden numerický sloupec (\texttt{some()}) nebo jen numerické sloupce (\texttt{every()}):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{df }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{some}\NormalTok{(is.numeric)  }\CommentTok{\# obsahuje df aspoň jeden numerický sloupec?}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{df }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{every}\NormalTok{(is.numeric)  }\CommentTok{\# obsahuje df pouze numerické sloupce?}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

Funkce \texttt{has\_element(.x,\ .y)} zobecňuje operátor \texttt{\%in\%}. Vrací \texttt{TRUE}, pokud vektor \texttt{.x} obsahuje objekt \texttt{.y}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, }\StringTok{"a"}\NormalTok{)  }\CommentTok{\# prvky x jsou vektory 1:5 a "a"}
\FunctionTok{has\_element}\NormalTok{(x, }\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{has\_element}\NormalTok{(x, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

Balík \textbf{purrr} nabízí i~užitečnou funkci \texttt{negate()}, která transformuje zadanou funkci tak, že vrací její negaci. Pokud bychom chtěli pomocí \texttt{keep()} a naší funkce \texttt{is.odd()} vybrat sudé prvky, museli bychom použít formuli:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{keep}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{10}\NormalTok{, }\SpecialCharTok{\textasciitilde{}} \SpecialCharTok{!}\FunctionTok{is.odd}\NormalTok{(.))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  2  4  6  8 10
\end{verbatim}

Pomocí funkce \texttt{negate()} však můžeme negovat celou predikátovou funkci \texttt{is.odd()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{keep}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{10}\NormalTok{, }\FunctionTok{negate}\NormalTok{(is.odd))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  2  4  6  8 10
\end{verbatim}

\hypertarget{vuxfdbux11br-a-uxfapravy-prvkux16f-vektorux16f}{%
\section{Výběr a úpravy prvků vektorů}\label{vuxfdbux11br-a-uxfapravy-prvkux16f-vektorux16f}}

Často potřebujeme ze složitější struktury získat jeden její prvek. Obecně k~tomu slouží funkce \texttt{{[}{[}} (dvojité hranaté závorky). Funkce \texttt{pluck(.x,\ ...,\ .default\ =\ NULL)} tuto myšlenku zobecňuje. Umožňuje vybrat libovolně zanořený prvek vektoru \texttt{.x}. Ukážeme si to na příkladu vektoru hráčů:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{dungeon }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{str}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 2
##  $ :List of 3
##   ..$ id   : num 11
##   ..$ name : chr "Karel"
##   ..$ items:List of 2
##   .. ..$ : chr "sword"
##   .. ..$ : chr "key"
##  $ :List of 3
##   ..$ id   : num 12
##   ..$ name : chr "Emma"
##   ..$ items:List of 3
##   .. ..$ : chr "mirror"
##   .. ..$ : chr "potion"
##   .. ..$ : chr "dagger"
\end{verbatim}

První parametr \texttt{pluck()} je vektor, ze kterého vybíráme. Další parametry jsou pozice nebo jména prvků, které vybíráme. Pokud zadáme víc položek, pak výběr funguje rekurzivně: druhá položka vybírá z~výsledku prvního výběru atd.:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pluck}\NormalTok{(dungeon, }\DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $id
## [1] 11
## 
## $name
## [1] "Karel"
## 
## $items
## $items[[1]]
## [1] "sword"
## 
## $items[[2]]
## [1] "key"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pluck}\NormalTok{(dungeon, }\DecValTok{1}\NormalTok{, }\StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Karel"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pluck}\NormalTok{(dungeon, }\DecValTok{1}\NormalTok{, }\StringTok{"items"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "sword"
## 
## [[2]]
## [1] "key"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pluck}\NormalTok{(dungeon, }\DecValTok{1}\NormalTok{, }\StringTok{"items"}\NormalTok{, }\DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "sword"
\end{verbatim}

K~výběru můžeme použít i~funkci, která vrací výběr z~vektoru:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{artefact }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x) x[[}\StringTok{"items"}\NormalTok{]]  }\CommentTok{\# funkce vrací artefakty vybraného hráče}
\FunctionTok{artefact}\NormalTok{(dungeon[[}\DecValTok{1}\NormalTok{]])  }\CommentTok{\# seznam všech artefaktů prvního hráče}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "sword"
## 
## [[2]]
## [1] "key"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pluck}\NormalTok{(dungeon, }\DecValTok{1}\NormalTok{, artefact, }\DecValTok{1}\NormalTok{)  }\CommentTok{\# 1. artefakt prvního hráče}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "sword"
\end{verbatim}

Všechny tyto výběry můžeme samozřejmě provést i~pomocí základních funkcí~R, syntaxe \texttt{pluck()} je však přehlednější. Poslední výběr bychom např.~museli zadat takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{artefact}\NormalTok{(dungeon[[}\DecValTok{1}\NormalTok{]])[[}\DecValTok{1}\NormalTok{]]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "sword"
\end{verbatim}

Pokud hledaný prvek ve vektoru neexistuje, funkce \texttt{pluck()} vrátí \texttt{NULL}. Tuto hodnotu můžeme změnit pomocí parametru \texttt{.default}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pluck}\NormalTok{(dungeon, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## NULL
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pluck}\NormalTok{(dungeon, }\DecValTok{3}\NormalTok{, }\AttributeTok{.default =} \ConstantTok{NA}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] NA
\end{verbatim}

Pokud bychom potřebovali, aby funkce raději zhavarovala, můžeme místo \texttt{pluck()} použít funkci \texttt{chuck(x,\ ...)}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{chuck}\NormalTok{(dungeon, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: Index 1 exceeds the length of plucked object (3 > 2)
\end{verbatim}

Funkce \texttt{pluck()} umožňuje i~měnit hodnotu vybraného prvku (zde bohužel není možné při výběru použít funkci jako je např.~naše funkce \texttt{artefact()}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pluck}\NormalTok{(dungeon, }\DecValTok{1}\NormalTok{, }\StringTok{"items"}\NormalTok{, }\DecValTok{1}\NormalTok{) }\OtherTok{\textless{}{-}} \StringTok{"megaweapon"}
\FunctionTok{str}\NormalTok{(dungeon)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 2
##  $ :List of 3
##   ..$ id   : num 11
##   ..$ name : chr "Karel"
##   ..$ items:List of 2
##   .. ..$ : chr "megaweapon"
##   .. ..$ : chr "key"
##  $ :List of 3
##   ..$ id   : num 12
##   ..$ name : chr "Emma"
##   ..$ items:List of 3
##   .. ..$ : chr "mirror"
##   .. ..$ : chr "potion"
##   .. ..$ : chr "dagger"
\end{verbatim}

První hráč má nyní místo meče nějakou ``megazbraň''.

Pokud potřebujete změnit nějaký prvek vektoru, můžete použít funkce \texttt{assign\_in()} a \texttt{modify\_in()}. Na jejich použití se podívejte do dokumentace.

\hypertarget{zabezpeux10denuxed-iteracuxed-proti-chybuxe1m}{%
\section{Zabezpečení iterací proti chybám}\label{zabezpeux10denuxed-iteracuxed-proti-chybuxe1m}}

Pokud jedna z~iterací ve funkci \texttt{map()} a spol. skončí chybou, skončí chybou celé volání této funkce. Pak může být obtížné zjistit, který prvek vektoru chybu způsobil. Jedním z~přínosů balíku \textbf{purrr} je to, že zavádí několik speciálních funkcí, které umožňují tento problém vyřešit. Všechny tyto funkce fungují tak, že transformují funkci \texttt{.f} ještě před tím, než vstoupí do \texttt{map()}~-- na vstupu vezmou funkci a vrací její zabezpečenou verzi odolnou vůči selhání.

První z~těchto funkcí je \texttt{safely(.f,\ otherwise\ =\ NULL,\ quiet\ =\ TRUE)}. Tato funkce bere na vstupu iterovanou funkci a vrací její modifikovanou verzi, která nikdy neskončí chybou a která vrací seznam dvou prvků: výsledku a chybového objektu. Pokud původní funkce proběhla, má chybová hlášení hodnotu~\texttt{NULL}, pokud skončila chybou, má hodnotu~\texttt{NULL} výsledek. Protože funkce vrací seznam, je možné ji použít pouze ve funkci \texttt{map()}, ne v~jejích zjednodušujících variantách jako je \texttt{map\_lgl()} apod.

Ukážeme si použití této funkce na příkladu. Máme seznam~\texttt{v}, který obsahuj většinou čísla, mezi která je však přimíchaný jeden řetězec. Pro každý prvek~\texttt{v} chceme spočítat vektor jeho logaritmů (pomocí funkce \texttt{map()} přesto, že funkce \texttt{log()} je vektorizovaná). Přímé volání funkce \texttt{log()} skončí chybou:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\StringTok{"a"}\NormalTok{, }\DecValTok{5}\NormalTok{)}
\FunctionTok{map}\NormalTok{(v, log)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error in .Primitive("log")(x, base): non-numeric argument to mathematical function
\end{verbatim}

Pokud funkci \texttt{log()} ``obalíme'' funkcí \texttt{safely()}, výpočet proběhne až do konce a výsledkem bude struktura popsaná výše. Všimněte si, že v~1., 2. a 4.~prvku struktury má chybová složka hodnotu~\texttt{NULL}. Ve 3.~prvku, který zhavaroval, obsahuje chybová složka seznam, který obsahuje objekt třídy \emph{error}. Ruční prohlídka našeho výsledku by nám umožnila zjistit, že je to 3.~prvek vektoru~\texttt{v}, který způsobuje chyby:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{result }\OtherTok{\textless{}{-}} \FunctionTok{map}\NormalTok{(v, }\FunctionTok{safely}\NormalTok{(log))}
\FunctionTok{str}\NormalTok{(result)  }\CommentTok{\# struktura výsledku}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 4
##  $ :List of 2
##   ..$ result: num 0
##   ..$ error : NULL
##  $ :List of 2
##   ..$ result: num 0.693
##   ..$ error : NULL
##  $ :List of 2
##   ..$ result: NULL
##   ..$ error :List of 2
##   .. ..$ message: chr "non-numeric argument to mathematical function"
##   .. ..$ call   : language .Primitive("log")(x, base)
##   .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
##  $ :List of 2
##   ..$ result: num 1.61
##   ..$ error : NULL
\end{verbatim}

Ruční hledání chyb je však možné jen v~případě, že zpracovávaná data jsou velmi malá. Balík \textbf{purrr} naštěstí umožňuje proces hledání chyby zautomatizovat. Stačí na výsledek předchozího výpočtu použít funkci \texttt{transpose()}, která změní seznam párů na pár seznamů. Výraz \texttt{transpose(result)} tedy vrátí seznam dvou prvků: první obsahuje všechny výsledky a druhý všechna chybová hlášení (oboje uložené jako seznamy):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{transpose}\NormalTok{(result)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $result
## $result[[1]]
## [1] 0
## 
## $result[[2]]
## [1] 0.6931472
## 
## $result[[3]]
## NULL
## 
## $result[[4]]
## [1] 1.609438
## 
## 
## $error
## $error[[1]]
## NULL
## 
## $error[[2]]
## NULL
## 
## $error[[3]]
## <simpleError in .Primitive("log")(x, base): non-numeric argument to mathematical function>
## 
## $error[[4]]
## NULL
\end{verbatim}

To nám umožní najít problematické prvky vektoru~\texttt{v} např.~tak, že vybereme pouze část chybových hlášení a z~ní sestavíme logický vektor, který bude mít hodnotu~\texttt{TRUE} tam, kde hodnota chyby není~\texttt{NULL}, tj.~volání funkce selhalo. Logický vektor pak můžeme použít k~nalezení indexů prvků vektoru, kde k~chybě došlo (pomocí funkce \texttt{which()}), nebo k~vypsání hodnot, které chybu způsobily:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bugs }\OtherTok{\textless{}{-}} \FunctionTok{transpose}\NormalTok{(result)}\SpecialCharTok{$}\NormalTok{error  }\CommentTok{\# transpozice a výběr chybové složky}
\NormalTok{bugs }\OtherTok{\textless{}{-}} \SpecialCharTok{!}\FunctionTok{map\_lgl}\NormalTok{(bugs, is.null)  }\CommentTok{\# TRUE, kde error není NULL, tj. kde je chyba}
\FunctionTok{which}\NormalTok{(bugs)  }\CommentTok{\# index prvků v, kde nastala chyba (jako vektor)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x[bugs]  }\CommentTok{\# hodnoty prvků v, kde nastala chyba (jako seznam)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## NULL
\end{verbatim}

Pokud nás nezajímají chyby, ale pouze ty výsledky, které se skutečně spočítaly, můžeme použít funkci \texttt{possibly(.f,\ otherwise,\ quiet\ =\ TRUE)}. Tato funkce zabezpečí funkci \texttt{.f} tak, že nikdy nezhavaruje. Pokud není schopná spočítat výsledek, vrátí místo něj hodnotu zadanou v~parametru \texttt{otherwise} (pokud není zadána, funkce zhavaruje). Díky tomu funkce \texttt{possibly()} vrací jen vlastní výsledky, takže může být využitá i~ve zjednodušujících variantách \texttt{map()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_dbl}\NormalTok{(v, }\FunctionTok{possibly}\NormalTok{(log, }\AttributeTok{otherwise =} \ConstantTok{NA\_real\_}\NormalTok{))  }\CommentTok{\# chybná hodnota je nahrazena NA}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 0.0000000 0.6931472        NA 1.6094379
\end{verbatim}

Pokud byste místo zachytávání chyb potřebovali zachytit zprávy a varování, která vrací iterovaná funkce, můžete použít funkci \texttt{quietly(.f)}.

Poslední funkce, kterou balík \textbf{purrr} nabízí k~ovlivnění výpočtu, je funkce \texttt{auto\_browse(.f)}, která transformuje funkci~\texttt{.f} tak, že v~případě chyby, automaticky spustí ladící mechanismus:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map}\NormalTok{(v, }\FunctionTok{auto\_browse}\NormalTok{(log))}
\end{Highlighting}
\end{Shaded}

\hypertarget{sec:reduce}{%
\section{Rekurzivní kombinace prvků vektorů}\label{sec:reduce}}

Někdy máme seznam objektů, na které potřebujeme aplikovat funkci, která však bere jen dva vstupy. Patrně nejdůležitější příklad takového užití je spojení mnoha tabulek uložených v~seznamu pomocí funkce \texttt{left\_join()}, se kterým se seznámíte v~kapitole~\ref{kap:dplyr}. V~takovém případě chceme aplikovat funkci postupně: nejprve spojit první dvě tabulky, pak k~výsledku připojit třetí tabulku, k~výsledku tohoto spojení čtvrtou atd. Balík \textbf{purrr} k~tomuto účelu nabízí čtyři funkce: \texttt{reduce(.x,\ .f,\ ...,\ .init,\ .dir\ =\ c("forward",\ "backward"))} a \texttt{reduce2(.x,\ .y,\ .f,\ ...,\ .init)} a \texttt{accumulate(.x,\ .f,\ ...,\ .init,\ .dir\ =\ c("forward",\ "backward"))} a \texttt{accumulate2(.x,\ .y,\ .f,\ ...,\ .init)}. My se zde podíváme jen na funkce \texttt{reduce()} a \texttt{accumulate()}, které pracují nad jedním seznamem; druhé dvě funkce pracují paralelně nad dvěma.

Funkce \texttt{accumulate()} postupně aplikuje na vektor \texttt{.x} funkci \texttt{.f} a vrací seznam stejné délky jako \texttt{.x} (nebo o~1~delší, viz dále). Prvním prvkem výsledného vektoru je \texttt{.x{[}{[}1{]}{]}}, druhým \texttt{.f(.x{[}{[}1{]}{]},\ .x{[}{[}2{]}{]})}, třetím \texttt{.f(.f(.x{[}{[}1{]}{]},\ .x{[}{[}2{]}{]}),\ .x{[}{[}3{]}{]})} atd. Pokud tedy ``akumulujeme'' atomický vektor čísel \(1, 2, \ldots, N\) pomocí funkce součtu~\texttt{+}, pak dostaneme atomický vektor čísel \(1, 1 + 2, 1 + 2 + 3, \dots\), tedy totéž, co by nám vrátila funkce \texttt{cumsum()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{accumulate}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, }\StringTok{\textasciigrave{}}\AttributeTok{+}\StringTok{\textasciigrave{}}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  3  6 10 15
\end{verbatim}

Funkce \texttt{reduce()} funguje podobně, ale vrací jen finální výsledek akumulace, zde tedy součet všech prvků vektoru:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{reduce}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, }\StringTok{\textasciigrave{}}\AttributeTok{+}\StringTok{\textasciigrave{}}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 15
\end{verbatim}

Podívejme se nyní na realističtější příklad. Řekněme, že máme seznam atomických vektorů, které obsahují id jedinců, kteří se zúčastnili nějakých akcí. Zajímá nás, kteří jedinci, se zúčastnili \emph{všech} těchto akcí, tj.~hledáme průnik všech těchto množin. K~tomu slouží funkce \texttt{intersect(x,\ y)}, která však umí vrátit pouze průnik dvou množin. Musíme ji tedy použít na všechny prvky seznamu rekurzivně. Protože nás zajímá jen finální průnik, použijeme funkci \texttt{reduce()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{riots }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(  }\CommentTok{\# seznam id účastníků různých akcí}
  \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{7}\NormalTok{, }\DecValTok{9}\NormalTok{),}
  \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{4}\NormalTok{, }\DecValTok{8}\NormalTok{, }\DecValTok{9}\NormalTok{),}
  \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{9}\NormalTok{)}
\NormalTok{)}
\FunctionTok{reduce}\NormalTok{(riots, intersect)  }\CommentTok{\# celkový průsečík množin}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 9
\end{verbatim}

Funkce \texttt{reduce()} a \texttt{accumulate()} umožňují zadat i~počáteční hodnotu pomocí parametru \texttt{.init}. To se hodí v~případě, kdy by akumulovaný vektor mohl být prázdný a my nechceme, aby výpočet zhavaroval.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{v }\OtherTok{\textless{}{-}} \FunctionTok{numeric}\NormalTok{(}\DecValTok{0}\NormalTok{)}
\FunctionTok{reduce}\NormalTok{(v, }\StringTok{\textasciigrave{}}\AttributeTok{+}\StringTok{\textasciigrave{}}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: `.x` is empty, and no `.init` supplied
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{reduce}\NormalTok{(v, }\StringTok{\textasciigrave{}}\AttributeTok{+}\StringTok{\textasciigrave{}}\NormalTok{, }\AttributeTok{.init =} \DecValTok{0}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 0
\end{verbatim}

Pokud zadáme parametr \texttt{.init}, bude výsledek funkce \texttt{accumulate()} o~1~delší než vstupní vektor.

Parametr \texttt{.dir} umožňuje nastavit směr akumulace (implicitně se akumuluje od prvního prvku vektoru po poslední). Detaily najdete v dokumentaci.

\hypertarget{paralelizace-vuxfdpoux10dtu}{%
\section{Paralelizace výpočtu}\label{paralelizace-vuxfdpoux10dtu}}

Funkce \texttt{map()} a spol. pracují s~každým prvkem vektoru samostatně a izolovaně, takže nezáleží na pořadí, v~jakém jsou tyto prvky zpracovány. To, mimo jiné, umožňuje paralelizaci výpočtu, tj.~zpracování každého prvku na jiném jádře počítače nebo jiném prvku počítačového klastru. Pokud jsou data tak velká, že se to vyplatí, je možné použít balík \textbf{furrr}.
Balík \textbf{furrr} implementuje paralelizované ekvivalenty funkcí \texttt{map()}, \texttt{map2()}, \texttt{pmap()}, \texttt{modify()} a všech jejich variant, které zjednodušují výsledek na atomický vektor nebo tabulku jako je \texttt{map\_dbl()} nebo transformují jen vybrané prvky jako \texttt{map\_at()}. Tyto alternativní funkce mají konzistentní pojmenování: před jméno dané funkce připojují \texttt{future\_}, takže místo \texttt{map()} máme \texttt{future\_map()} apod. Všechny tyto funkce také vracejí stejné výsledky a berou stejné parametry jako odpovídající funkce z~balíku \textbf{purrr} (plus parametr \texttt{.progress}, který umožňuje sledovat průběh výpočtu pomocí progress baru, a parametr \texttt{.options}, který umožňuje předávat dodatečné informace paralelizačnímu stroji).

Před použitím těchto funkcí je třeba nejen načíst balík \textbf{furrr}, ale i~nastavit paralelizaci. K~tomu slouží funkce \texttt{plan()}. Její hlavní parametr určuje, jak se bude paralelizovat. Implicitní hodnota je \texttt{sequential}, tj.~normální výpočet na jednom jádře bez paralelizace. Typické nastavení je

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(furrr)}
\FunctionTok{plan}\NormalTok{(multiprocess)}
\end{Highlighting}
\end{Shaded}

které nastaví nejlepší dostupnou paralelizaci na daném stroji. Vlastní iterace jsou pak stejné jako s~balíkem \textbf{purrr}, stačí jen přidat \texttt{future\_} ke jménu funkce, tj.~např.~volat:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{future\_map\_dbl}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{5}\NormalTok{, }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{\^{}} \DecValTok{2}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  4  9 16 25
\end{verbatim}

Na velmi stylizovaném příkladu si ukážeme, jak paralelizace zrychluje výpočet. Pomocí funkce \texttt{map()} a \texttt{future\_map()} spustíme třikrát výraz \texttt{Sys.sleep(1)}, který na 1~sekundu pozastaví výpočet. Pomocí funkce \texttt{system.time()} změříme, jak dlouho tento ``výpočet'' trval:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{system.time}\NormalTok{(}\FunctionTok{map}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{Sys.sleep}\NormalTok{(}\DecValTok{1}\NormalTok{)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##    user  system elapsed 
##   0.004   0.000   3.006
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{system.time}\NormalTok{(}\FunctionTok{future\_map}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{Sys.sleep}\NormalTok{(}\DecValTok{1}\NormalTok{)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##    user  system elapsed 
##   0.053   0.032   1.162
\end{verbatim}

Zatímco s~pomocí \texttt{map()} trval, jak bychom očekávali, zhruba tři sekundy, s~pomocí \texttt{future\_map()} zabral jen o~málo víc než 1~sekundu, protože každé jednotlivé volání \texttt{Sys.sleep(1)} proběhlo na mém osmijádrovém počítači v~jiném sezení~R. Výsledek by byl ještě rychlejší, kdybych na svém Linuxovém stroji nekompiloval tento text v~RStudiu, viz dále.

Implicitně se používají všechna jádra počítače. To je možné změnit tak, že nejprve pomocí funkce \texttt{availableCores()} zjistíme počet dostupných jader, a~pak nastavíme počet jader použitých výpočtu ve funkci \texttt{plan()} pomocí parametru \texttt{workers}. Pokud tedy chceme např.~jedno jádro ušetřit pro ostatní procesy běžící na počítači, můžeme paralelizaci naplánovat takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{n\_cores }\OtherTok{\textless{}{-}} \FunctionTok{availableCores}\NormalTok{()}
\FunctionTok{plan}\NormalTok{(multiprocess, }\AttributeTok{workers =}\NormalTok{ n\_cores }\SpecialCharTok{{-}} \DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Popis podporovaných způsobů paralelizace najdete v~dokumentaci k~funkci \texttt{plan()} a v~základní vinětě k~balíku \textbf{future}, který se stará o~backend. Základní způsoby paralelizace jsou čtyři: \texttt{sequential} provádí jednotlivé výpočty normálně bez paralelizace na jednom jádře, \texttt{multisession} spouští jednotlivé výpočty v~nových kopiích~R, \texttt{multicore} vytváří forky procesů~R a \texttt{cluster} používá počítačový klastr. Ve většině případů budeme pracovat na jednom počítači, takže volíme mezi \texttt{multisession} a \texttt{multicore}. \texttt{mulitcore} je při tom efektivnější, protože nemusí kopírovat pracovní prostředí (globální proměnné, balíky apod.) do nového procesu, zatímco \texttt{multisession} musí překopírovat potřebné objekty do nového sezení~R. \texttt{multicore} však není dostupný ve Windows, které fork vůbec nepodporují, ani při spuštění výpočtu v~rámci RStudia. Nejrozumnější je proto použít \texttt{multiprocess}, který buď o~zavolá \texttt{multicore} (na Linuxu nebo macOS při spuštění R mimo RStudio) nebo \texttt{multisession} (jinak).

Při spuštění \texttt{multisession} musí \texttt{future\_map()} a spol. překopírovat do nového sezení potřebné proměnné. Většinou to funguje bezproblémově automaticky. Pokud však něco selže, přečtěte si viněty k~balíku \textbf{future}, které vysvětlují, jak potřebné proměnné do nového sezení nakopírovat ručně a jak vyřešit i~další případné problémy. Ani jeden z~autorů tohoto textu však při použití \textbf{furrr} zatím na takový problém nenarazil.

Potřeba přesouvat data do a z~nového procesu také znamená, že paralelní výpočet na čtyřech jádrech nebude typicky čtyřikrát rychlejší než na jednom. Pokud byste spouštěli jen malý počet velmi rychlých výpočtů na velkých datech, mohlo by se dokonce stát, že výpočet bude \emph{pomalejší} než na jednom jádře. Paralelizovat se tak vyplatí jen výpočty, kde každé spuštění funkce nad prvkem seznamu trvá poměrně dlouho nebo se zpracovává poměrně hodně prvků.

\hypertarget{sec:lapply-for}{%
\section{Srovnání map() s~cyklem for}\label{sec:lapply-for}}

Většinu začátečníků funkce typu \texttt{map()} děsí a snaží se daný problém řešit pomocí cyklů. To je samozřejmě možné. Vraťme se k~příkladu, kdy máme nějakou tabulku a chceme zjistit, kolik který její sloupec obsahuje chybějících hodnot.
Pomocí funkce \texttt{map\_int()} to uděláme na jednom řádku:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{map\_int}\NormalTok{(df, }\SpecialCharTok{\textasciitilde{}} \FunctionTok{sum}\NormalTok{(}\FunctionTok{is.na}\NormalTok{(.)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  names income   rent   loan 
##      0      0      0      0
\end{verbatim}

Pokud budeme místo toho chtít použít cyklus \texttt{for}, bude náš kód vypadat takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{result }\OtherTok{\textless{}{-}} \FunctionTok{integer}\NormalTok{(}\FunctionTok{ncol}\NormalTok{(df))}
\ControlFlowTok{for}\NormalTok{ (k }\ControlFlowTok{in} \FunctionTok{seq\_len}\NormalTok{(}\FunctionTok{ncol}\NormalTok{(df)))}
\NormalTok{    result[k] }\OtherTok{\textless{}{-}} \FunctionTok{sum}\NormalTok{(}\FunctionTok{is.na}\NormalTok{(df[[k]]))}
\FunctionTok{names}\NormalTok{(result) }\OtherTok{\textless{}{-}} \FunctionTok{names}\NormalTok{(df)}
\NormalTok{result}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  names income   rent   loan 
##      0      0      0      0
\end{verbatim}

Výsledek je v~obou případech stejný, ale kód napsaný pomocí cyklů má několik nevýhod: 1)~Kód napsaný pomocí cyklu \texttt{for} bývá obvykle delší a podstatně méně přehledný. Funkce \texttt{map()} jasně ukazuje, na jakých datech se iteruje a co se na nich iteruje. V~kódu cyklu to není zdaleka tak jasně vidět. 2)~Při použití cyklu \texttt{for} musíte myslet na víc věcí: musíte si předalokovat vektor pro uložení výsledku, musíte vektor pojmenovat (pokud o~to stojíte) a musíte přemýšlet, jestli použijete jednoduché nebo dvojité hranaté závorky (podle toho, zda je původní vektor a výsledek atomický vektor, seznam, nebo tabulka typu \emph{data.frame} nebo \emph{tibble}). 3)~Zaplevelíte si pracovní prostředí nechtěnými proměnnými: možná proměnnou \texttt{result}, určitě však počítadlem cyklu~\texttt{k}. A~4)~Mapovací funkce je mnohem jednodušší paralelizovat. Obecně je proto lepší vždy používat funkce typu \texttt{map()} raději než explicitní cyklus~\texttt{for}.

Přesto však existují situace, kdy je využití cyklů nezbytné. Hlavní případy jsou dva: 1)~Když výpočet \(i\)-té hodnoty záleží na některé z~hodnot spočítaných dříve a 2)~když pro ušetření času nahrazujeme hodnoty přímo v~původní datové struktuře, místo abychom celou strukturu vytvářeli znovu. V~ostatních situacích je téměř vždy rozumnější použít některou z~funkcí typu \texttt{map()}.

\hypertarget{aplikace}{%
\section{Aplikace}\label{aplikace}}

Někdy potřebujeme načíst velké množství tabulek z~jednotlivých \texttt{.csv} souborů, zkontrolovat jejich konzistenci a spojit je dohromady. To dělá následující kód, který představuje zjednodušenou verze části jednoho mého projektu:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# načtení potřebných balíků}
\FunctionTok{library}\NormalTok{(readr)}
\FunctionTok{library}\NormalTok{(purrr)}
\CommentTok{\# adresář s daty}
\NormalTok{DATADIR }\OtherTok{\textless{}{-}} \FunctionTok{file.path}\NormalTok{(}\StringTok{".."}\NormalTok{, }\StringTok{"testdata"}\NormalTok{)}
\CommentTok{\# seznam jmen souborů, které splňují určitou masku danou regulárním výrazem}
\NormalTok{PRODUCT\_FILES }\OtherTok{\textless{}{-}} \FunctionTok{dir}\NormalTok{(DATADIR, }\StringTok{"products\_.*}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{.csv}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{.gz"}\NormalTok{, }\AttributeTok{full.names =} \ConstantTok{TRUE}\NormalTok{)}
\CommentTok{\# načtení jednotlivých souborů, sloupcům vnutíme typ řetězec}
\NormalTok{product\_data }\OtherTok{\textless{}{-}} \FunctionTok{map}\NormalTok{(PRODUCT\_FILES,}
                    \SpecialCharTok{\textasciitilde{}} \FunctionTok{read\_csv2}\NormalTok{(}\AttributeTok{file =}\NormalTok{ ., }\AttributeTok{col\_types =} \FunctionTok{cols}\NormalTok{(}\AttributeTok{.default =} \StringTok{"c"}\NormalTok{))}
\CommentTok{\# kontrola, že všechny tabulky mají stejnou strukturu}
\NormalTok{product\_col\_names }\OtherTok{\textless{}{-}} \FunctionTok{map}\NormalTok{(product\_data, colnames)}
\NormalTok{product\_col\_names\_test }\OtherTok{\textless{}{-}} \FunctionTok{map\_chr}\NormalTok{(product\_col\_names,}
                                  \SpecialCharTok{\textasciitilde{}} \FunctionTok{all.equal}\NormalTok{(product\_col\_names[[}\DecValTok{1}\NormalTok{]], .))}
\ControlFlowTok{if}\NormalTok{ (}\SpecialCharTok{!}\NormalTok{(}\FunctionTok{all}\NormalTok{(}\FunctionTok{identical}\NormalTok{(product\_col\_names\_test,}
                    \FunctionTok{rep}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\AttributeTok{length =} \FunctionTok{length}\NormalTok{(product\_col\_names))))))}
    \FunctionTok{stop}\NormalTok{(}\StringTok{"Product data sets have different columns!"}\NormalTok{)}
\CommentTok{\# spojení jednotlivých tabulek do jedné}
\NormalTok{product\_data }\OtherTok{\textless{}{-}} \FunctionTok{reduce}\NormalTok{(product\_data, rbind)}
\end{Highlighting}
\end{Shaded}

Vlastní spojení dat je možné provést efektivněji pomocí funkce \texttt{bind\_rows()} z~balíku \textbf{dplyr}, která je efektivnější a rychlejší:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{product\_data }\OtherTok{\textless{}{-}}\NormalTok{ dplyr}\SpecialCharTok{::}\FunctionTok{bind\_rows}\NormalTok{(product\_data)}
\end{Highlighting}
\end{Shaded}

\hypertarget{part-naux10duxedtuxe1nuxed-a-ukluxe1duxe1nuxed-dat}{%
\part{Načítání a ukládání dat}\label{part-naux10duxedtuxe1nuxed-a-ukluxe1duxe1nuxed-dat}}

\hypertarget{naux10duxedtuxe1nuxed-a-ukluxe1duxe1nuxed-dat-ze-souborux16f}{%
\chapter{Načítání a ukládání dat ze souborů}\label{naux10duxedtuxe1nuxed-a-ukluxe1duxe1nuxed-dat-ze-souborux16f}}

Práce s~daty začíná vždy jejich načtením a často končí jejich uložením. V~této kapitole se naučíte:

\begin{itemize}
\tightlist
\item
  co jsou to textové delimitované tabulární soubory, jak je načíst a uložit
\item
  jak pracovat s~nedelimitovanými textovými tabulárními soubory
\item
  jak pracovat s~komprimovanými soubory textovými a soubory na webu
\item
  jak uložit a načíst data do nativního R-kového binárního souboru
\item
  jak pracovat s~daty uloženými v~balících
\item
  jak načíst data uložená v~souboru MS~Excel
\item
  jak pracovat s~daty ve formátu statistických programů SPSS, SAS a Stata
\item
  jak zkontrolovat integritu načtených dat
\end{itemize}

\hypertarget{sec:read-csv}{%
\section{Textové tabulární delimitované soubory}\label{sec:read-csv}}

Základní způsob výměny dat jsou textové tabulární delimitované formáty, kde jednotlivé řádky odpovídají pozorováním a kde jsou sloupce (proměnné) odděleny nějakým jasně definovaným znakem, např.~mezerou, čárkou, středníkem nebo dvojtečkou. Velká výhoda těchto formátů je, že je možné je načíst téměř do každého softwaru, který pracuje s~daty a stejně tak je z~něj i~vypsat. Zároveň jsou data ``čitelná lidmi'' a pokud se něco pokazí, je často možné data nějak zachránit. Nevýhodou je, že tyto formáty mohou obsahovat pouze tabulární data (tabulky), jednoduché datové typy (tj.~ne složitější objekty, jako jsou např.~odhady modelů), nemohou obsahovat metadata (např.~atributy), jejich načítání může trvat dlouho (pokud jsou data velká) a že data v~těchto formátech na disku zabírají hodně místa (pokud nejsou komprimovaná).

Příkladem dat v~textovém tabulárním formátu je např.~soubor ``bmi\_data.csv''. Na disku vypadá takto:

\begin{verbatim}
id,height,weight,bmi
1,153,55,23.4952368747
2,207,97,22.6376344839
3,173,83,27.7322997761
4,181,92,28.0821708739
5,164,112,41.6418798334
\end{verbatim}

Zde se podíváme na to, jak data v~textovém tabulárním formátu načíst a uložit pomocí funkcí z~balíku \textbf{readr}. Oproti podobným funkcím ze základního~R, tyto funkce načítají data rychleji, umožňují přesněji určit, jak se mají data načíst a neprovádí některé nepříjemné úpravy. Před použitím těchto funkcí musíme nejdříve načíst balík \textbf{readr}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(readr)}
\end{Highlighting}
\end{Shaded}

\hypertarget{naux10duxedtuxe1nuxed-dat}{%
\subsection{Načítání dat}\label{naux10duxedtuxe1nuxed-dat}}

Všechny funkce z~balíku \textbf{readr}, které sloužící k~načítání dat, jsou pojmenované \texttt{read\_XXX()}, kde \texttt{XXX} je jméno načítaného formátu. Data ve formátu CSV tedy načítá funkce \texttt{read\_csv()}. (Pozor! Funkce ze základního~R určené k~načtení těchto dat jsou pojmenované téměř stejně, jen místo podtržítka je jméno formátu oddělené tečkou. Obdobou funkce \texttt{read\_csv()} je funkce \texttt{read.csv()} ze základního balíku. Přestože se funkce jmenují podobně, mají výrazně odlišný interface i~chování.) Všechny funkce \texttt{read\_XXX()} z~balíku \textbf{readr} vracejí tabulku třídy \emph{tibble}.

Základní funkcí k~načtení textových delimitovaných tabulárních dat je funkce \texttt{read\_delim()}. Při jejím použití je potřeba zadat zejména dva parametry: jméno načítaného souboru včetně cesty a v~parametru \texttt{delim} znak, který odděluje jednotlivé proměnné v~datech. V~našem případě nastavíme \texttt{delim\ =\ ","}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi\_data }\OtherTok{\textless{}{-}} \FunctionTok{read\_delim}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{, }\AttributeTok{delim =} \StringTok{","}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Rows: 5 Columns: 4
\end{verbatim}

\begin{verbatim}
## -- Column specification ----------------------------------------------------------------------------------------------
## Delimiter: ","
## dbl (4): id, height, weight, bmi
\end{verbatim}

\begin{verbatim}
## 
## i Use `spec()` to retrieve the full column specification for this data.
## i Specify the column types or set `show_col_types = FALSE` to quiet this message.
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi\_data}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 4
##      id height weight   bmi
##   <dbl>  <dbl>  <dbl> <dbl>
## 1     1    153     55  23.5
## 2     2    207     97  22.6
## 3     3    173     83  27.7
## 4     4    181     92  28.1
## 5     5    164    112  41.6
\end{verbatim}

Textová tabulární data mohou mít jednotlivé proměnné oddělené různě. Existují však tři nejobvyklejší varianty, pro které má \textbf{readr} speciální varianty funkce \texttt{read\_delim()}:

\begin{itemize}
\tightlist
\item
  \texttt{read\_csv()} načítá klasický americký standard CSV, kde jsou jednotlivé proměnné oddělené čárkami a celou a desetinnou část čísla odděluje desetinná tečka,
\item
  \texttt{read\_csv2()} načítá ``evropskou'' variantu CSV, kde jsou jednotlivé proměnné oddělené středníky a desetinná místa v~číslech odděluje čárka a
\item
  \texttt{read\_tsv()} načítá variantu formátu, kde jsou proměnné oddělené tabelátorem.
\end{itemize}

V~těchto funkcích není potřeba nastavovat parametr~\texttt{delim}; většinu ostatních parametrů mají tyto funkce stejné jako funkce \texttt{read\_delim()}.

Protože dataset ``bmi\_data.csv'' splňuje klasický formát CSV, můžeme jej pohodlněji načíst i~pomocí funkce \texttt{read\_csv()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi\_data }\OtherTok{\textless{}{-}} \FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Rows: 5 Columns: 4
\end{verbatim}

\begin{verbatim}
## -- Column specification ----------------------------------------------------------------------------------------------
## Delimiter: ","
## dbl (4): id, height, weight, bmi
\end{verbatim}

\begin{verbatim}
## 
## i Use `spec()` to retrieve the full column specification for this data.
## i Specify the column types or set `show_col_types = FALSE` to quiet this message.
\end{verbatim}

Všechny funkce \texttt{read\_XXX()} berou první řádek datového souboru implicitně jako jména proměnných. Pokud soubor jména proměnných neobsahuje, je to třeba funkcím říct pomocí parametru \texttt{col\_names}. Ten může nabývat jedné ze tří hodnot. Pokud má hodnotu \texttt{TRUE}, pak první řádek souboru chápe jako jména proměnných. Pokud má hodnotu \texttt{FALSE}, pak se předpokládá, že první řádek souboru jména proměnných neobsahuje; z~řádku se načtou data a funkce sama jednotlivé proměnné pojmenuje \texttt{X1}, \texttt{X2} atd. Třetí možností je zadat jména proměnných ručně. V~tomto případě musí být parametr \texttt{col\_names} zadán jako vektor řetězců, který obsahuje jména jednotlivých proměnných. Na rozdíl od funkcí ze základního~R, funkce z~balíku \textbf{readr} jména proměnných nijak nemodifikují. V~důsledku toho nemusejí být jména proměnných platnými názvy proměnných v~R. To je však vždy možné opravit pomocí funkce \texttt{names()} nebo \texttt{setNames()}.

Ukážeme si to na příkladu. Soubor ``bmi\_data\_headless.csv'' obsahuje stejná data jako soubor ``bmi\_data.csv'', na prvním řádku však nejsou uvedena jména sloupců, ale dataset začíná přímo daty. Pokud bychom dataset načetli stejně jako výše, funkce \texttt{read\_csv()} by první řádek použila k~pojmenování proměnných (jména sloupců by navíc v~našem případě byla syntakticky nepřípustná, takže bychom je museli používat spolu se zpětnými apostrofy):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data\_headless.csv"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Rows: 4 Columns: 4
\end{verbatim}

\begin{verbatim}
## -- Column specification ----------------------------------------------------------------------------------------------
## Delimiter: ","
## dbl (4): 1, 153, 55, 23.4952368747
\end{verbatim}

\begin{verbatim}
## 
## i Use `spec()` to retrieve the full column specification for this data.
## i Specify the column types or set `show_col_types = FALSE` to quiet this message.
\end{verbatim}

\begin{verbatim}
## # A tibble: 4 x 4
##     `1` `153`  `55` `23.4952368747`
##   <dbl> <dbl> <dbl>           <dbl>
## 1     2   207    97            22.6
## 2     3   173    83            27.7
## 3     4   181    92            28.1
## 4     5   164   112            41.6
\end{verbatim}

Tomu můžeme zabránit tak, že nastavíme parametr \texttt{col\_names\ =\ FALSE}, takže se první řádek souboru považuje za data:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data\_headless.csv"}\NormalTok{,}
         \AttributeTok{col\_names =} \ConstantTok{FALSE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Rows: 5 Columns: 4
\end{verbatim}

\begin{verbatim}
## -- Column specification ----------------------------------------------------------------------------------------------
## Delimiter: ","
## dbl (4): X1, X2, X3, X4
\end{verbatim}

\begin{verbatim}
## 
## i Use `spec()` to retrieve the full column specification for this data.
## i Specify the column types or set `show_col_types = FALSE` to quiet this message.
\end{verbatim}

\begin{verbatim}
## # A tibble: 5 x 4
##      X1    X2    X3    X4
##   <dbl> <dbl> <dbl> <dbl>
## 1     1   153    55  23.5
## 2     2   207    97  22.6
## 3     3   173    83  27.7
## 4     4   181    92  28.1
## 5     5   164   112  41.6
\end{verbatim}

V~takovém případě se sloupce tabulky pojmenují \texttt{X1}, \texttt{X2} atd. Alternativně můžeme pomocí parametru \texttt{col\_names} přímo zadat jména jednotlivých sloupců, např.~jako \texttt{col\_names\ =\ c("id",\ "výška",\ "váha",\ "bmi")} (první řádek souboru se bude opět považovat za data):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data\_headless.csv"}\NormalTok{,}
         \AttributeTok{col\_names =} \FunctionTok{c}\NormalTok{(}\StringTok{"id"}\NormalTok{, }\StringTok{"výška"}\NormalTok{, }\StringTok{"váha"}\NormalTok{, }\StringTok{"bmi"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Rows: 5 Columns: 4
\end{verbatim}

\begin{verbatim}
## -- Column specification ----------------------------------------------------------------------------------------------
## Delimiter: ","
## dbl (4): id, výška, váha, bmi
\end{verbatim}

\begin{verbatim}
## 
## i Use `spec()` to retrieve the full column specification for this data.
## i Specify the column types or set `show_col_types = FALSE` to quiet this message.
\end{verbatim}

\begin{verbatim}
## # A tibble: 5 x 4
##      id výška  váha   bmi
##   <dbl> <dbl> <dbl> <dbl>
## 1     1   153    55  23.5
## 2     2   207    97  22.6
## 3     3   173    83  27.7
## 4     4   181    92  28.1
## 5     5   164   112  41.6
\end{verbatim}

Některé datové soubory obsahují v~prvních řádcích nějaké balastní informace, např.~údaje o~pořízení dat, copyrightu, parametrech simulace apod. Tyto řádky je možné přeskočit pomocí parametru \texttt{skip}: např.~\texttt{skip\ =\ 5} znamená, že se má přeskočit prvních pět řádků. Podobně některé soubory obsahují mezi skutečnými daty komentáře. Pokud jsou tyto komentáře uvozeny nějakým jasným znakem, můžeme je při načítání dat přeskočit pomocí parametru \texttt{comment}: např.~\texttt{comment\ =\ "\#"} znamená, že se přeskočí všechny řádky, které začínají ``křížkem''.

Opět si to ukážeme na příkladu. Soubor ``bmi\_data\_comments.csv'' opět obsahuje stejná data jako ``bmi\_data.csv'', na prvních dvou řádcích však obsahuje nějaké informace o~experimentu. Na disku vypadá soubor takto:

\begin{verbatim}
Experiment no. 747.
Top secret
id,height,weight,bmi
1,153,55,23.4952368747
2,207,97,22.6376344839
3,173,83,27.7322997761
4,181,92,28.0821708739
5,164,112,41.6418798334
\end{verbatim}

Tento soubor musíme načíst s~pomocí parametru~\texttt{skip}; v~opačném případě se věci opravdu pokazí (vyzkoušejte si to):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data\_comments.csv"}\NormalTok{, }\AttributeTok{skip =} \DecValTok{2}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Rows: 5 Columns: 4
\end{verbatim}

\begin{verbatim}
## -- Column specification ----------------------------------------------------------------------------------------------
## Delimiter: ","
## dbl (4): id, height, weight, bmi
\end{verbatim}

\begin{verbatim}
## 
## i Use `spec()` to retrieve the full column specification for this data.
## i Specify the column types or set `show_col_types = FALSE` to quiet this message.
\end{verbatim}

\begin{verbatim}
## # A tibble: 5 x 4
##      id height weight   bmi
##   <dbl>  <dbl>  <dbl> <dbl>
## 1     1    153     55  23.5
## 2     2    207     97  22.6
## 3     3    173     83  27.7
## 4     4    181     92  28.1
## 5     5    164    112  41.6
\end{verbatim}

Soubor ``bmi\_data\_comments2.csv'' obsahuje opět stejná data; nyní jsou však dvě množiny pozorování nadepsány komentáři a jeden řádek má také vlastní komentář:

\begin{verbatim}
id,height,weight,bmi
# the first set of observations
1,153,55,23.4952368747
2,207,97,22.6376344839
3,173,83,27.7322997761  # suspicious
# the second set of observations
4,181,92,28.0821708739
5,164,112,41.6418798334
\end{verbatim}

V~tomto případě musíme zadat znak, kterým začínají komentáře, pomocí parametru~\texttt{comment}. Funkce \texttt{read\_XXX()} pak ignorují vše od tohoto znaku do konce řádku:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data\_comments2.csv"}\NormalTok{, }\AttributeTok{comment =} \StringTok{"\#"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Rows: 5 Columns: 4
\end{verbatim}

\begin{verbatim}
## -- Column specification ----------------------------------------------------------------------------------------------
## Delimiter: ","
## dbl (4): id, height, weight, bmi
\end{verbatim}

\begin{verbatim}
## 
## i Use `spec()` to retrieve the full column specification for this data.
## i Specify the column types or set `show_col_types = FALSE` to quiet this message.
\end{verbatim}

\begin{verbatim}
## # A tibble: 5 x 4
##      id height weight   bmi
##   <dbl>  <dbl>  <dbl> <dbl>
## 1     1    153     55  23.5
## 2     2    207     97  22.6
## 3     3    173     83  27.7
## 4     4    181     92  28.1
## 5     5    164    112  41.6
\end{verbatim}

Různé datové soubory kódují chybějící hodnoty různě. Standardně funkce \texttt{read\_XXX()} očekávají, že chybějící hodnota je buď prázdná, nebo obsahuje řetězec ``NA''. To je však možné změnit parametrem \texttt{na}. Do něj uložíte vektor všech hodnot, které má funkce \texttt{read\_XXX()} považovat za \texttt{NA}. Pokud např.~váš datový soubor kóduje chybějící hodnoty pomocí tečky, nastavíte \texttt{na\ =\ "."}. Pokud navíc může být zadaná chybějící hodnota i~jako prázdný řetězec nebo řetězec~``NA'', zadáte \texttt{na\ =\ c("",\ ".",\ "NA")}. (Funkce \texttt{read\_XXX()} při načítání jednotlivých hodnot implicitně odstraní všechny úvodní a koncové mezery, takže našemu ``tečkovému'' pravidlu vyhoví jak řetězce ``.'', tak i~" . ". Toto chování můžete změnit parametrem \texttt{trim\_ws}.) Následující kód ukazuje příklad:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data\_na.csv"}\NormalTok{, }\AttributeTok{na =} \FunctionTok{c}\NormalTok{(}\StringTok{""}\NormalTok{, }\StringTok{"."}\NormalTok{, }\StringTok{"NA"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Rows: 5 Columns: 4
\end{verbatim}

\begin{verbatim}
## -- Column specification ----------------------------------------------------------------------------------------------
## Delimiter: ","
## dbl (4): id, height, weight, bmi
\end{verbatim}

\begin{verbatim}
## 
## i Use `spec()` to retrieve the full column specification for this data.
## i Specify the column types or set `show_col_types = FALSE` to quiet this message.
\end{verbatim}

\begin{verbatim}
## # A tibble: 5 x 4
##      id height weight   bmi
##   <dbl>  <dbl>  <dbl> <dbl>
## 1     1    153     55  23.5
## 2     2    207     97  22.6
## 3     3     NA     83  27.7
## 4     4    181     NA  28.1
## 5     5    164    112  41.6
\end{verbatim}

Jak jste si asi všimli, funkce \texttt{read\_XXX()} při načítání dat samy odhadnou, jaká data obsahují jednotlivé proměnné, a~převedou je na daný datový typ. (Výsledná tabulka třídy \emph{tibble} tyto typy vypisuje pod jmény proměnných.) Informace o~tom, jaký typ funkce zvolila pro který sloupec, se vypíše při načítání: informace začíná ``Parsed with column specification: cols(\ldots{}'', viz výše. V~našem případě se např.~první tři proměnné převedly na celá čísla, zatímco poslední proměnná na reálné číslo. Funkce \texttt{read\_XXX()} odhadují typ proměnné na základě prvních 1~000 načtených řádků (toto číslo je možné změnit pomocí parametru \texttt{guess\_max}).
Nechat si datový typ odhadnout, je pohodlné, ale nepříliš bezpečné. Mnohem rozumnější je zadat datový typ jednotlivých sloupců ručně pomocí parametru \texttt{col\_types}. Ten je možné zadat třemi způsoby. Zaprvé, hodnota~\texttt{NULL} indikuje, že se typy proměnných mají odhadnout. Zadruhé, datové typy jednotlivých sloupců je možné zadat plnými jmény ve funkci \texttt{cols()}. A~zatřetí, tato jména můžeme zkrátit do jednopísmenných zkratek zadaných v~jednom řetězci. Seznam typů sloupců a jejich zkratek uvádí tabulka~\ref{tab:reader-cols}. Rozdíl mezi funkcemi \texttt{col\_double()} a \texttt{col\_number()} spočívá v~tom, že \texttt{col\_number()} umožňuje mít před a za vlastním číslem nějaké nečíselné znaky, které zahodí. To se hodí např.~při načítání peněžních údajů, kde \texttt{col\_number()} zvládne převést na číslo i~řetězce jako \texttt{\$15.30} nebo \texttt{753\ Kč}.

\begin{longtable}[]{@{}llll@{}}
\caption{\label{tab:reader-cols} Seznam jmen funkcí pro určení datového typu načítané proměnné.}\tabularnewline
\toprule
funkce & význam & zkratka & parametry \\
\midrule
\endfirsthead
\toprule
funkce & význam & zkratka & parametry \\
\midrule
\endhead
\texttt{col\_logical()} & logická proměnná & ``l'' & \\
\texttt{col\_integer()} & striktní celé číslo & ``i'' & \\
\texttt{col\_double()} & striktní reálné číslo & ``d'' & \\
\texttt{col\_number()} & flexibilní číslo & ``n'' & \\
\texttt{col\_character()} & řetězec & ``c'' & \\
\texttt{col\_date()} & datum (jen den bez hodin) & ``D'' & \texttt{format} \\
\texttt{col\_datetime()} & datum (den i hodina) & ``T'' & \texttt{format} \\
\texttt{col\_time()} & čas (jen hodiny, minuty a sekundy) & ``t'' & \texttt{format} \\
\texttt{col\_factor()} & faktor & & \texttt{levels}, \texttt{ordered}, \texttt{include\_na} \\
\texttt{col\_guess()} & typ odhadne R & ``?'' & \\
\texttt{col\_skip()} & proměnná se přeskočí a nenačte & "\_" nebo ``-'' & \\
\bottomrule
\end{longtable}

Přesně stejného výsledku, jakého v~našem případě dosáhlo automatické rozpoznávání typů sloupců, můžeme dosáhnout manuálně takto (v~tomto případě~R nevypíše informaci o~sloupcích):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi\_data }\OtherTok{\textless{}{-}} \FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{,}
                     \AttributeTok{col\_types =} \FunctionTok{cols}\NormalTok{(}\AttributeTok{id =} \FunctionTok{col\_integer}\NormalTok{(),}
                                      \AttributeTok{height =} \FunctionTok{col\_integer}\NormalTok{(),}
                                      \AttributeTok{weight =} \FunctionTok{col\_integer}\NormalTok{(),}
                                      \AttributeTok{bmi =} \FunctionTok{col\_double}\NormalTok{()))}
\end{Highlighting}
\end{Shaded}

nebo stručněji takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi\_data }\OtherTok{\textless{}{-}} \FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{,}
                     \AttributeTok{col\_types =} \StringTok{"iiid"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Specifikací sloupců můžeme samozřejmě změnit i~typ sloupců. Někdy např.~můžeme chtít načíst všechny proměnné jako řetězce, a~pak si je zkonvertovat sami. To můžeme udělat třemi způsoby: 1)~sloupce můžeme nastavit pomocí plného volání funkcí \texttt{col\_types\ =\ cols(id\ =\ col\_character(),\ height\ =\ col\_character(),\ weight\ =\ col\_character(),\ bmi\ =\ col\_character())}, 2)~je můžeme nastavit pomocí zkratkových písmen jako \texttt{col\_types\ =\ "cccc"} nebo 3)~nastavíme implicitní typ sloupce pomocí speciálního parametru \texttt{.default} buď plným voláním funkce \texttt{col\_types\ =\ cols(.default\ =\ col\_character())} nebo pomocí zkratkového písmene:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{,}
         \AttributeTok{col\_types =} \FunctionTok{cols}\NormalTok{(}\AttributeTok{.default =} \StringTok{"c"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 4
##   id    height weight bmi          
##   <chr> <chr>  <chr>  <chr>        
## 1 1     153    55     23.4952368747
## 2 2     207    97     22.6376344839
## 3 3     173    83     27.7322997761
## 4 4     181    92     28.0821708739
## 5 5     164    112    41.6418798334
\end{verbatim}

Nejjednodušší způsob, jak explicitně zadat datové typy sloupců tabulky, je nechat funkci~\texttt{read\_XXX()} odhadnout datový typ sloupců, a~pak specifikaci \texttt{cols()} zkopírovat a případně upravit. Po vlastním načtení je možné specifikaci získat i pomocí funkce \texttt{spec()}, jejímž jediným argumentem je načtená tabulka. Specifikaci je možné zjednodušit pomocí funkce \texttt{cols\_condense()}, která nejčastěji používaný datový typ shrne do parametru \texttt{.default}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{cols\_condense}\NormalTok{(}\FunctionTok{spec}\NormalTok{(bmi\_data))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## cols(
##   .default = col_integer(),
##   bmi = col_double()
## )
\end{verbatim}

Některé funkce \texttt{col\_XXX} umožňují zadat parametry. Funkce pro načítání data a času umožňují zadat formát, ve kterém je datum nebo čas uložen. Funkce pro načítání faktorů umožňují zadat platné úrovně faktoru, to, zda je faktor ordinální, a~to, zda má být hodnota~\texttt{NA} součástí úrovní faktoru. Úplný seznam parametrů uvádí tabulka~\ref{tab:reader-cols}. Pokud bychom např.~chtěli načíst proměnnou~\texttt{id} jako faktor se třemi úrovněmi (``1'', ``2'' a ``3''), můžeme to udělat takto (funkce \texttt{read\_XXX()} nikdy nic nepřevádí na faktory sami od sebe~-- pokud chcete proměnnou převést na faktor, musíte o~to požádat):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi\_data }\OtherTok{\textless{}{-}} \FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{,}
                     \AttributeTok{col\_types =} \FunctionTok{cols}\NormalTok{(}\AttributeTok{id =} \FunctionTok{col\_factor}\NormalTok{(}\AttributeTok{levels =} \FunctionTok{as.character}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{)),}
                                      \AttributeTok{height =} \FunctionTok{col\_integer}\NormalTok{(),}
                                      \AttributeTok{weight =} \FunctionTok{col\_integer}\NormalTok{(),}
                                      \AttributeTok{bmi =} \FunctionTok{col\_double}\NormalTok{()))}
\end{Highlighting}
\end{Shaded}

Funkce vypíše varování, protože proměnná \texttt{id} obsahuje i~jiné než povolené úrovně, a~nepovolené úrovně nahradí hodnotami~\texttt{NA}. (Pokud bychom chtěli nechat funkci \texttt{read\_XXX()} odhadnout úrovně faktoru z~dat, museli bychom zadat parametr \texttt{levels\ =\ NULL}.)

Funkcím \texttt{read\_XXX()} je možné sdělit i~to, které proměnné z~tabulky vyloučit. K~tomu slouží funkce \texttt{col\_skip()}. Řekněme, že bychom chtěli náši tabulku anonymizovat tím, že z~dat odstraníme identifikátory~\texttt{id}. Toho můžeme dosáhnout např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi\_data }\OtherTok{\textless{}{-}} \FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{,}
                     \AttributeTok{col\_types =} \FunctionTok{cols}\NormalTok{(}\AttributeTok{id =} \FunctionTok{col\_skip}\NormalTok{(),}
                                      \AttributeTok{height =} \FunctionTok{col\_integer}\NormalTok{(),}
                                      \AttributeTok{weight =} \FunctionTok{col\_integer}\NormalTok{(),}
                                      \AttributeTok{bmi =} \FunctionTok{col\_double}\NormalTok{()))}
\NormalTok{bmi\_data}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 3
##   height weight   bmi
##    <int>  <int> <dbl>
## 1    153     55  23.5
## 2    207     97  22.6
## 3    173     83  27.7
## 4    181     92  28.1
## 5    164    112  41.6
\end{verbatim}

Pokud bychom chtěli načíst jen některé proměnné, stačí nahradit funkci \texttt{cols()} funkcí \texttt{cols\_only()} a v~ní uvést pouze proměnné, které se mají načíst. Následující kód načte pouze proměnné \texttt{height} a \texttt{bmi}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi\_data }\OtherTok{\textless{}{-}} \FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{,}
                     \AttributeTok{col\_types =} \FunctionTok{cols\_only}\NormalTok{(}\AttributeTok{height =} \FunctionTok{col\_integer}\NormalTok{(),}
                                           \AttributeTok{bmi =} \FunctionTok{col\_double}\NormalTok{()))}
\NormalTok{bmi\_data}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 2
##   height   bmi
##    <int> <dbl>
## 1    153  23.5
## 2    207  22.6
## 3    173  27.7
## 4    181  28.1
## 5    164  41.6
\end{verbatim}

Jak jsme viděli výše, pokud se při načítání jednotlivých sloupců tabulky něco pokazí, funkce \texttt{read\_XXX()} o~tom vypíší varování a příslušnou ``buňku'' tabulky doplní hodnotou~\texttt{NA}. K~tomu může dojít z~různých důvodů: Datový typ, který jste zadali (nebo který R odhadlo na základě prvních 1~000~řádků) není dost obecný pro všechny řádky tabulky. První řádky např.~obsahují jen celá čísla, zatímco pozdější řádky i~reálná čísla. Faktor obsahuje i~jiné hodnoty, než zadané platné úrovně atd. Pokud je varování hodně, zobrazí se jen několik prvních varování. Všechna varování je možné vypsat funkcí \texttt{problems()}, jejímž jediným argumentem je načtená tabulka.

Většinou je moudré ladit zadání typů sloupců ve specifikaci \texttt{cols()} tak dlouho, až R~nevypisuje žádná varování. To je užitečné zejména v~případě, že načítáte různé datové soubory se stejnou strukturou. Když se potom u~některého souboru objeví varování, znamená to, že se v~datech něco změnilo. Pokud chcete být opravdu důkladně varováni, že k~tomu došlo, můžete použít funkci \texttt{stop\_for\_problems()}. Jejím jediným argumentem je načtená tabulka. Pokud při jeho načtení došlo k~nějakým varováním, funkce \texttt{stop\_for\_problems()} zastaví běh skriptu.

Tabulární datové soubory jsou obyčejné textové soubory bez speciálního formátování. Proto celá řada prvků těchto souborů není standardizovaná. Jednotlivé datové soubory se mohou lišit kódováním, znakem použitým pro oddělení celých a desetinných čísel, znakem použitým pro oddělení tisíců, jmény měsíců a dnů v~týdnu apod. Balík \textbf{readr} implicitně používá americkou konvenci: kódování je UTF-8, desetinná místa odděluje tečka, tisíce čárka a veškerá jména jsou anglická. Toto chování můžete změnit pomocí parametru \texttt{locale}, do kterého vložíte objekt vytvořený funkcí \texttt{locale()}. Její základní parametry uvádí tabulka~\ref{tab:reader-locale}.

\begin{longtable}[]{@{}lll@{}}
\caption{\label{tab:reader-locale} Seznam jmen funkcí pro určení datového typu načítané proměnné.}\tabularnewline
\toprule
parametr & význam & impl. hodnota \\
\midrule
\endfirsthead
\toprule
parametr & význam & impl. hodnota \\
\midrule
\endhead
\texttt{date\_names} & řetězec pro jména datumů (česká ``cs'', slovenská ``sk'') & ``en'' \\
\texttt{date\_format} & formát data & ``\%AD'' \\
\texttt{time\_format} & formát času & ``\%AT'' \\
\texttt{decimal\_mark} & znak pro oddělení desetinných míst & ``.'' \\
\texttt{grouping\_mark} & znak pro oddělení tisíců & ``,'' \\
\texttt{tz} & časová zóna & ``UTC'' \\
\texttt{encoding} & kódování souboru & ``UTF-8'' \\
\texttt{asciify} & jestli soubor odstranil diakritiku ze jmen datumů & \texttt{FALSE} \\
\bottomrule
\end{longtable}

Nastavení ve funkci \texttt{locale} si můžete vyzkoušet tak, že je necháte vypsat do konzoly. Typické české nastavení data vytvořená z~LibreOffice na Linuxu s~formátem data typu 31.~12.~2017 by vypadalo takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{locale}\NormalTok{(}\StringTok{"cs"}\NormalTok{,}
       \AttributeTok{date\_format =} \StringTok{"\%d.\%*\%m.\%*\%Y"}\NormalTok{,}
       \AttributeTok{decimal\_mark =} \StringTok{","}\NormalTok{, }\AttributeTok{grouping\_mark =} \StringTok{"."}\NormalTok{,}
       \AttributeTok{tz =} \StringTok{"Europe/Prague"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## <locale>
## Numbers:  123.456,78
## Formats:  %d.%*%m.%*%Y / %AT
## Timezone: Europe/Prague
## Encoding: UTF-8
## <date_names>
## Days:   neděle (ne), pondělí (po), úterý (út), středa (st), čtvrtek (čt), pátek
##         (pá), sobota (so)
## Months: ledna (led), února (úno), března (bře), dubna (dub), května (kvě),
##         června (čvn), července (čvc), srpna (srp), září (zář), října
##         (říj), listopadu (lis), prosince (pro)
## AM/PM:  dopoledne/odpoledne
\end{verbatim}

Složitější nastavení \texttt{locale}, např.~jak nastavit jména dnů a měsíců v~nepodporovaném jazyce nebo jak zjistit časovou zónu, najdete v~příslušné vinětě balíku \textbf{readr}.

Největší oříšek je v~našich končinách zjistit, jaké kódování má daný soubor. K~tomu může pomoci funkce \texttt{guess\_encoding()}, jejímž jediným parametrem je jméno souboru, jehož kódování chceme odhadnout. Funkce vypíše seznam několika kódování a u~nich pravděpodobnost, kterou tomuto kódování přikládá. Pokud funkci vyzkoušíme na našem testovacím souboru, dostaneme následující výsledek:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{guess\_encoding}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1 x 2
##   encoding confidence
##   <chr>         <dbl>
## 1 ASCII             1
\end{verbatim}

Protože náš soubor neobsahuje žádnou diakritiku, je si funkce \texttt{guess\_encoding()} zcela jistá, že se jedná o~ASCII soubor. (Protože ASCII je podmnožinou UTF-8, nemusíme kódování explicitně deklarovat.)

\hypertarget{naux10duxedtuxe1nuxed-velkuxfdch-souborux16f}{%
\subsection{Načítání velkých souborů}\label{naux10duxedtuxe1nuxed-velkuxfdch-souborux16f}}

Načítání velkých souborů funguje stejně jako načítání malých souborů~-- se dvěma specifiky: trvá déle a zabírá více operační paměti počítače. R~dokáže pracovat pouze s~proměnnými, které má v~operační paměti. Pokud se pokusíte načíst data, která se do paměti počítače nevejdou, R~spadne.
Pokud tedy máte opravdu hodně velký datový soubor, je užitečné dopředu zjistit, kolik paměti zabere. Objem dat v~paměti můžete přibližně odhadnout následujícím způsobem:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  zjistíte, kolik řádků má vaše tabulka (v~Linuxu to můžete udělat pomocí prográmku \texttt{wc}),
\item
  načtete prvních 1~000 řádků tabulky (počet řádků omezíte pomocí parametru \texttt{n\_max}); přitom odladíte datové typy jednotlivých sloupců,
\item
  zjistíte, kolik paměti tabulka zabírá pomocí funkce \texttt{object.size()} a
\item
  vypočítáte, kolik paměti zabere celý datový soubor: vydělíte velikost vzorku dat tisícem a vynásobíte ji počtem řádků souboru.
\end{enumerate}

Balík \textbf{readr} umožňuje do jisté míry omezení proměnných na operační paměť počítače obejít. K~tomu slouží speciální funkce \texttt{read\_XXX\_chunked()} (ekvivalentem funkce \texttt{read\_delim()} je funkce \texttt{read\_delim\_chunked()}). Tyto funkce čtou datový soubor po kusech. Nad každým kusem provedou nějakou agregační operaci (např.~vyberou jen řádky, které splňují určitou podmínku, spočítají nějaké agregátní statistiky apod.) a do paměti ukládají jen výsledky těchto operací. Na detaily použití těchto funkcí se podívejte do jejich dokumentace.

Naštěstí pro vás, valná většina dat, se kterou budete v~blízké budoucnosti pracovat, bude nejspíše tak malá, že nic z~těchto triků nebudete muset používat. Například tabulka s~milionem řádků a 20 sloupci, které všechny obsahují reálná čísla bude v~paměti počítač zabírat 1~000 ~000~\(\times\) 20~\(\times\) 8~\(=\) 160~000~000~bytů, tj.~asi jen 153~MB.

\hypertarget{ukluxe1duxe1nuxed-dat-do-textovuxfdch-tabuluxe1rnuxedch-delimitovanuxfdch-souborux16f}{%
\subsection{Ukládání dat do textových tabulárních delimitovaných souborů}\label{ukluxe1duxe1nuxed-dat-do-textovuxfdch-tabuluxe1rnuxedch-delimitovanuxfdch-souborux16f}}

K~zapsání dat do tabulárních formátů slouží funkce \texttt{write\_delim()}, \texttt{write\_csv()}, \texttt{write\_excel\_csv()} a \texttt{write\_tsv()}. Prvním parametrem všech těchto funkcí je vždy tabulka, který se má zapsat na disk, druhým je cesta, kam se mají data zapsat. Dále je možné nastavit pomocí parametru \texttt{na} znak pro uložení hodnoty~\texttt{NA} a určit, zda se mají data připsat na konec existujícího souboru. Funkce \texttt{read\_delim()} umožňuje navíc nastavit pomocí parametru \texttt{delim} znak, který bude oddělovat jednotlivé sloupce tabulky. Funkce \texttt{write\_excel\_csv()} přidá do souboru kromě běžného CSV i~znak, podle kterého MS~Excel pozná, že soubor je v~kódování UTF-8.

Tyto funkce bohužel neumožňují nastavit \texttt{locale}, takže výsledkem je vždy soubor v~kódování UTF-8 s~desetinnými místy oddělenými pomocí tečky, tisící oddělenými pomocí čárky atd. Pokud potřebujete něco jiného. podívejte se do dokumentace na odpovídající funkce ze základního~R (tj.~např.~funkci \texttt{write.csv()}).

\hypertarget{spojenuxed-connections}{%
\subsection{Spojení (connections)}\label{spojenuxed-connections}}

Když R čte nebo zapisuje data, nepracuje přímo se soubory, ale se ``spojeními'' (connections). Spojení zobecňuje myšlenku souboru~-- spojení může být lokální soubor, soubor komprimovaný algoritmem \texttt{gzip}, \texttt{bzip2} apod., URL a další.

Funkce \texttt{read\_XXX()} vytvářejí spojení pro čtení dat automaticky. To znamená, že jméno souboru může obsahovat jak lokální soubor, tak URL. Internetový odkaz funkce pozná podle úvodního ``\url{http://}'', ``\url{https://}'', ``\url{ftp://}'' nebo ``ftps://''. V~takovém případě vzdálený soubor automaticky stáhne. Funkce umí číst i~některý typy komprimovaných souborů. Ty pozná podle koncovky ``.gz'', ``.bz2'', .``xz'' nebo ``.zip''. Takový soubor funkce automaticky dekomprimuje.

Předpokládejme, že náš datový soubor je pro úsporu místa na disku komprimovaný pomocí programu \texttt{gzip}. Pak data načteme jednoduše takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bmi\_data }\OtherTok{\textless{}{-}} \FunctionTok{read\_csv}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv.gz"}\NormalTok{,}
                     \AttributeTok{col\_types =} \StringTok{"iiid"}\NormalTok{)}
\NormalTok{bmi\_data}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 4
##      id height weight   bmi
##   <int>  <int>  <int> <dbl>
## 1     1    153     55  23.5
## 2     2    207     97  22.6
## 3     3    173     83  27.7
## 4     4    181     92  28.1
## 5     5    164    112  41.6
\end{verbatim}

Podobně je možné načíst i~data z~internetu, stačí nahradit jméno souboru jeho URL:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{country\_codes }\OtherTok{\textless{}{-}} \FunctionTok{read\_csv}\NormalTok{(}
    \StringTok{"http://www.correlatesofwar.org/data{-}sets/cow{-}country{-}codes/cow{-}country{-}codes"}\NormalTok{,}
    \AttributeTok{col\_types =} \StringTok{"cic"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## New names:
## * `40` -> `40...10`
## * `40` -> `40...12`
## * `41` -> `41...14`
## * `41` -> `41...16`
## * `42` -> `42...18`
## * ...
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{head}\NormalTok{(country\_codes)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning in fansi::strwrap_ctl(x, width = max(width, 0), indent = indent, :
## Encountered a C0 control character, see `?unhandled_ctl`; you can use
## `warn=FALSE` to turn off these warnings.
\end{verbatim}

\begin{verbatim}
## # A tibble: 0 x 489
## # ... with 489 variables: StateAbb <chr>, CCode <int>, StateNme
USA <chr>,
## #   2 <chr>, United States of America
CAN <chr>, 20 <chr>, Canada
BHM <chr>,
## #   31 <chr>, Bahamas
CUB <chr>, 40...10 <chr>, Cuba
CUB <chr>, 40...12 <chr>,
## #   Cuba
HAI <chr>, 41...14 <chr>, Haiti
HAI <chr>, 41...16 <chr>,
## #   Haiti
DOM <chr>, 42...18 <chr>, Dominican Republic
DOM <chr>, 42...20 <chr>,
## #   Dominican Republic
JAM <chr>, 51 <chr>, Jamaica
TRI <chr>, 52 <chr>,
## #   Trinidad and Tobago
BAR <chr>, 53 <chr>, Barbados
DMA <chr>, 54 <chr>,
## #   Dominica
GRN <chr>, 55 <chr>, Grenada
SLU <chr>, 56 <chr>,
## #   St. Lucia
SVG <chr>, 57 <chr>, St. Vincent and the Grenadines
AAB <chr>,
## #   58 <chr>, Antigua & Barbuda
SKN <chr>, 60 <chr>,
## #   St. Kitts and Nevis
MEX <chr>, 70 <chr>, Mexico
BLZ <chr>, 80 <chr>,
## #   Belize
GUA <chr>, 90 <chr>, Guatemala
HON <chr>, 91 <chr>, Honduras
SAL <chr>,
## #   92 <chr>, El Salvador
NIC <chr>, 93 <chr>, Nicaragua
COS <chr>, 94 <chr>,
## #   Costa Rica
PAN <chr>, 95 <chr>, Panama
COL <chr>, 100 <chr>,
## #   Colombia
VEN <chr>, 101 <chr>, Venezuela
GUY <chr>, 110 <chr>,
## #   Guyana
SUR <chr>, 115 <chr>, Suriname
ECU <chr>, 130 <chr>, Ecuador
PER <chr>,
## #   135 <chr>, Peru
BRA <chr>, 140 <chr>, Brazil
BOL <chr>, 145 <chr>,
## #   Bolivia
PAR <chr>, 150...72 <chr>, Paraguay
PAR <chr>, 150...74 <chr>,
## #   Paraguay
CHL <chr>, 155 <chr>, Chile
ARG <chr>, 160 <chr>,
## #   Argentina
URU <chr>, 165 <chr>, Uruguay
UKG <chr>, 200 <chr>,
## #   United Kingdom
IRE <chr>, 205 <chr>, Ireland
NTH <chr>, 210...86 <chr>,
## #   Netherlands
NTH <chr>, 210...88 <chr>, Netherlands
BEL <chr>, 211...90 <chr>,
## #   Belgium
BEL <chr>, 211...92 <chr>, Belgium
LUX <chr>, 212...94 <chr>,
## #   Luxembourg
LUX <chr>, 212...96 <chr>, Luxembourg
FRN <chr>, 220...98 <chr>,
## #   France
FRN <chr>, 220...100 <chr>, ...
\end{verbatim}

Na rozdíl od funkcí ze základního~R umí funkce \texttt{write\_XXX()} i~přímo zapisovat do komprimovaných souborů bez toho, aby bylo potřeba \emph{connection} explicitně deklarovat (např.~pomocí funkce \texttt{gzfile()}). Stačí uvést jméno souboru ukončené odpovídající koncovkou. Pokud tedy chceme uložit naši tabulku do komprimovaného souboru, můžeme to provést např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{write\_csv}\NormalTok{(bmi\_data, }\StringTok{"moje\_data.csv.gz"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Víc detailů ke spojením najdete např.~v~\citep[s.~23--25]{Spector2008} nebo \citep[s.~33--35]{PengRProgramming}.

\hypertarget{naux10dtenuxed-tabuluxe1rnuxedch-dat-v-rstudiu}{%
\subsection{Načtení tabulárních dat v~RStudiu}\label{naux10dtenuxed-tabuluxe1rnuxedch-dat-v-rstudiu}}

Při interaktivní práci je možné využít toho, že RStudio umí načíst tabulární textová data. V~záložce \texttt{Environment} klikněte na \texttt{Import\ Dataset} a zvolte \texttt{From\ Text\ (readr)...}, viz levá část obrázku~\ref{fig:readr-text-tabular}. Nástroj odhadne většinu potřebných parametrů a zbytek (včetně \texttt{locale}) je možné konfigurovat, viz pravá část obrázku~\ref{fig:readr-text-tabular}. Příjemné je, že nástroj vygeneruje i~potřebný kód, který můžete překopírovat do svého skriptu. Nástroj vám tedy umožní vizuálně odladit základní nastavení načítání dat, detaily můžete doladit později ve skriptu.

\begin{figure}
\includegraphics[width=10.95in]{figs/readr/readr_text_tabular} \caption{Načtení dat z tabulárního formátu v RStudiu.}\label{fig:readr-text-tabular}
\end{figure}

\hypertarget{dalux161uxed-textovuxe9-formuxe1ty}{%
\section{Další textové formáty}\label{dalux161uxed-textovuxe9-formuxe1ty}}

Balík \textbf{readr} umožňuje číst data i~z~dalších typů textových formátů. Nejjednodušším případem jsou tabulární formáty, které nejsou delimitované, tj.~jednotlivé sloupce nejsou oddělené jasně definovaným znakem. Sem patří zejména dva typy formátů. V~prvním jsou jednotlivé sloupce oddělené mezerami (nebo jinými ``bílými znaky'', např.~tabelátory). V~ideálním případě jsou mají všechny sloupce díky bílým znakům právě stejnou šířku. K~načtení těchto formátů slouží funkce \texttt{read\_table()} a \texttt{read\_table2()}. Druhou možností jsou formáty s~pevnou šířkou sloupců. K~jejich načtení můžete použít funkci \texttt{read\_fwf()}. Všechny tyto funkce mají syntaxi velmi podobnou funkcím na čtení delimitovaných formátů.

Soubor ``bmi\_data.txt'' obsahuje stejná data jako výše, ovšem tentokrát jsou oddělená jen bílými místy, v~našem případě mezerami:

\begin{verbatim}
id height weight           bmi
 1    153     55 23.4952368747
 2    207     97 22.6376344839
 3    173     83 27.7322997761
 4    181     92 28.0821708739
 5    164    112 41.6418798334
\end{verbatim}

Použít funkce \texttt{read\_delim()} a její speciální varianty není možné, protože nemáme jasný oddělující znak (dokonce ani mezera by nefungovala, vyzkoušejte si to a vysvětlete, proč). Naštěstí pro nás je možné tato data snadno načíst pomocí funkce \texttt{read\_table()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_table}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.txt"}\NormalTok{,}
           \AttributeTok{col\_types =} \StringTok{"iiid"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 4
##      id height weight   bmi
##   <int>  <int>  <int> <dbl>
## 1     1    153     55  23.5
## 2     2    207     97  22.6
## 3     3    173     83  27.7
## 4     4    181     92  28.1
## 5     5    164    112  41.6
\end{verbatim}

Naše tabulka má všechny sloupce stejně široké, můžeme tedy použít i funkci \texttt{read\_fwf()}. V~tomto případě je však třeba specifikovat hranice jednotlivých sloupců. K~tomu slouží pomocné funkce \texttt{fwf\_empty()}, \texttt{fwf\_widths}, \texttt{fwf\_positions()} a \texttt{fwf\_cols()}. Nejjednodušší z~nich je funkce \texttt{fwf\_widths()}, do které se zadává šířka jednotlivých sloupců. Formát FWF také nepodporuje jména sloupců, takže musíme přeskočit první řádek, který jména obsahuje, a~jména sloupců zadat ručně ve funkci \texttt{fwf\_widths()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_fwf}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.txt"}\NormalTok{,}
         \FunctionTok{fwf\_widths}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\DecValTok{2}\NormalTok{, }\DecValTok{7}\NormalTok{, }\DecValTok{7}\NormalTok{, }\DecValTok{13}\NormalTok{), }\FunctionTok{c}\NormalTok{(}\StringTok{"id"}\NormalTok{, }\StringTok{"výška"}\NormalTok{, }\StringTok{"váha"}\NormalTok{, }\StringTok{"bmi"}\NormalTok{)),}
         \AttributeTok{col\_types =} \StringTok{"iiid"}\NormalTok{,}
         \AttributeTok{skip =} \DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 4
##      id výška  váha   bmi
##   <int> <int> <int> <dbl>
## 1     1   153    55  23.5
## 2     2   207    97  22.6
## 3     3   173    83  27.7
## 4     4   181    92  28.1
## 5     5   164   112  41.6
\end{verbatim}

Na další detaily se podívejte do dokumentace. Balík \textbf{readr} neobsahuje žádné funkce pro výpis do těchto formátů.

V~případě, že textová data nejsou formátována ani jedním z~výše popsaných formátů, je možné načíst textový soubor jako řetězec a data si zpracovat sami pomocí funkcí, které se naučíte v~kapitole~\ref{kap:strings}. K~načtení textového souboru po jednotlivých řádcích slouží funkce \texttt{read\_lines()} a \texttt{read\_lines\_raw()}, které načtou jednotlivé řádky ze souboru a uloží je do vektoru řetězců, kde každý prvek odpovídá jednomu řádku. Obě funkce umožní zadat, kolik řádků načíst (parametr \texttt{n\_max}) a kolik počátečních řádků přeskočit (parametr \texttt{skip}). Funkce \texttt{read\_lines()} umožňuje zadat i~kódování textu pomocí \texttt{locale} způsobem popsaným výše.
Náš testovací datový soubor bychom načetli takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{read\_lines}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "id,height,weight,bmi"    "1,153,55,23.4952368747" 
## [3] "2,207,97,22.6376344839"  "3,173,83,27.7322997761" 
## [5] "4,181,92,28.0821708739"  "5,164,112,41.6418798334"
\end{verbatim}

Funkce \texttt{write\_lines()} umožňuje uložit vektor řetězců do souboru. Na detaily se podívejte do dokumentace.

Pokud není způsob, jakým jsou v~textovém souboru data rozdělena do řádků, užitečný, je možné načíst celý soubor do jednoho řetězce. K~tomu slouží funkce \texttt{read\_file()} a \texttt{read\_file\_raw()}. Funkce \texttt{write\_file()} zapíše řetězec do souboru. Detaily použití opět najdete v~dokumentaci.

\hypertarget{nativnuxed-r-kovuxe9-binuxe1rnuxed-soubory}{%
\section{Nativní R-kové binární soubory}\label{nativnuxed-r-kovuxe9-binuxe1rnuxed-soubory}}

Textové tabulární datové formáty jsou výborné při předávání dat mezi lidmi. Při vlastním zpracování dat je však výhodnější použít vlastní binární datový formát~R. Jeho výhodou je, že data zabírají na disku méně místa, načítají se rychleji, mohou jakékoli datové typy včetně složitých objektů, obsahovat metadata včetně atributů a jde v~nich ukládat i~jiná data, než jsou tabulky (např.~seznamy, pole, různé objekty apod.).

K~uložení jednotlivých proměnných slouží funkce \texttt{save()}. Nejdříve se uvedou jména všech proměnných, které se mají uložit, a~pak cesta k~souboru, kam se mají uložit (další parametry jsou popsány v~dokumentaci). Cestu je nutné zadat pojmenovaných parametrem \texttt{file}. Data se do těchto souborů obvykle ukládají s~koncovkami \texttt{.RData} nebo \texttt{.rda}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{save}\NormalTok{(bmi\_data, }\AttributeTok{file =} \StringTok{"bmi\_data.RData"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Pokud je proměnných více, oddělí se čárkou:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{save}\NormalTok{(var1, var2, var3, var4, }\AttributeTok{file =} \StringTok{"somefile.RData"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Někdy chcete uložit všechny proměnné, které máte v~paměti~R. K~tomu slouží funkce \texttt{save.image()} (detaily viz dokumentace).

Data uložená pomocí funkcí \texttt{save()} nebo \texttt{save.image()} načteme do~pracovního prostředí~R pomocí funkce \texttt{load()}. Funkce načte všechny proměnné obsažené v~daném datovém soubory včetně metadat, tj.~není možné si vybrat jen jednotlivé proměnné uložené v~souboru. Proměnným zůstanou jejich původní jména, tj.~není možné načíst vybranou proměnnou do nové proměnné. Funkce data načte do pracovního prostředí, tj.~nevrací je jako hodnotu funkce. Jediným důležitým parametrem funkce \texttt{load()} je cesta k~datovému souboru:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{load}\NormalTok{(}\StringTok{"bmi\_data.RData"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Pokud chcete do nativního binárního souboru uložit jen obsah jedné proměnné a ten pak opět načíst do nové proměnné, můžete použít dvojici funkcí \texttt{saveRDS()} a \texttt{readRDS()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{saveRDS}\NormalTok{(bmi\_data, }\AttributeTok{file =} \StringTok{"bmi\_data.RData"}\NormalTok{)}
\NormalTok{bmi }\OtherTok{\textless{}{-}} \FunctionTok{readRDS}\NormalTok{(}\StringTok{"bmi\_data.RData"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\hypertarget{naux10duxedtuxe1nuxed-dat-z-baluxedkux16f}{%
\section{Načítání dat z balíků}\label{naux10duxedtuxe1nuxed-dat-z-baluxedkux16f}}

Mnoho balíků v~R obsahuje nějaká data. K~načtení těchto dat slouží funkce \texttt{data()}. Stejně jako funkce \texttt{load()} ani tato funkce data nevrací, nýbrž je jako svůj vedlejší efekt načte přímo do pracovního prostředí~R:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(ggplot2)}
\FunctionTok{data}\NormalTok{(}\StringTok{"diamonds"}\NormalTok{)}
\FunctionTok{head}\NormalTok{(diamonds)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 10
##   carat cut       color clarity depth table price     x     y     z
##   <dbl> <ord>     <ord> <ord>   <dbl> <dbl> <int> <dbl> <dbl> <dbl>
## 1  0.23 Ideal     E     SI2      61.5    55   326  3.95  3.98  2.43
## 2  0.21 Premium   E     SI1      59.8    61   326  3.89  3.84  2.31
## 3  0.23 Good      E     VS1      56.9    65   327  4.05  4.07  2.31
## 4  0.29 Premium   I     VS2      62.4    58   334  4.2   4.23  2.63
## 5  0.31 Good      J     SI2      63.3    58   335  4.34  4.35  2.75
## 6  0.24 Very Good J     VVS2     62.8    57   336  3.94  3.96  2.48
\end{verbatim}

Funkce \texttt{data()} může vypsat i~seznam dat obsažených v~daném balíku:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{data}\NormalTok{(}\AttributeTok{package =} \StringTok{"ggplot2"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Funkce \texttt{data()} umožňuje i~načíst data bez načtení balíku. K~tomu stačí zadat jméno balíku:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{data}\NormalTok{(}\StringTok{"economics"}\NormalTok{, }\AttributeTok{package =} \StringTok{"ggplot2"}\NormalTok{)}
\FunctionTok{head}\NormalTok{(economics)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 6
##   date         pce    pop psavert uempmed unemploy
##   <date>     <dbl>  <dbl>   <dbl>   <dbl>    <dbl>
## 1 1967-07-01  507. 198712    12.6     4.5     2944
## 2 1967-08-01  510. 198911    12.6     4.7     2945
## 3 1967-09-01  516. 199113    11.9     4.6     2958
## 4 1967-10-01  512. 199311    12.9     4.9     3143
## 5 1967-11-01  517. 199498    12.8     4.7     3066
## 6 1967-12-01  525. 199657    11.8     4.8     3018
\end{verbatim}

Některé balíky zpřístupní svá data hned při svém načtení, takže není třeba je zpřístupňovat pomocí funkce \texttt{data()}. Tato data jsou obvykle zpřístupněna ``líně'': implicitně se data nenačtou do paměti, ale pouze do vyhledávací cesty. Do paměti počítače se načtou až ve chvíli, kdy je poprvé jakkoli použijete.

Data v~balících bývají obvykle dokumentovaná stejným způsobem, jako funkce. Nápověda je tedy dostupná pomocí funkce \texttt{help()} i~pomocí otazníku. Po načtení dat \texttt{economics} můžete dokumentaci zobrazit např.~takto: \texttt{?economics}.

\hypertarget{naux10duxedtuxe1nuxed-dat-z-ms-excelu}{%
\section{Načítání dat z MS~Excelu}\label{naux10duxedtuxe1nuxed-dat-z-ms-excelu}}

Někteří lidé (a~některé statistické úřady) dávají data k~dispozici jako soubory uložené z~Microsoft Excelu. Používat tato data může být poněkud ošidné, protože datové ``buňky'' jsou často obalené různým balastem, který je potřeba odstranit.
Nejbezpečnějším způsobem načtení dat z~Excelu je tak data v~Excelu ručně upravit, následně vyexportovat do CSV souboru a ten pak načíst způsobem popsaným v~oddíle~\ref{sec:read-csv}. Tak máte největší kontrolu nad tím, co se děje.

Data z~Excelu je však v~R možné načíst i~přímo pomocí balíku \textbf{readxl} (umí načíst jak soubory\texttt{.xls}, tak \texttt{.xlsx}). Balík poskytuje dvě hlavní funkce: \texttt{excel\_sheets()} a \texttt{read\_excel()}.
Funkce \texttt{excel\_sheets()} má jediný argument (jméno souboru) a vypíše seznam listů, které Excelový soubor obsahuje.

Funkce \texttt{read\_excel()} načte jeden list z~Excelového souboru a vrátí jej jako tabulku třídy \emph{tibble}. Jejím prvním parametrem je opět název excelového souboru. Druhým parametrem (\texttt{sheet}) určíte, který list se má načíst (implicitně první). List je možné zadat jménem (jako řetězec), nebo pozicí (jako celé číslo). Parametr \texttt{range} určuje oblast, která se má z~excelového listu načíst (implicitně celý list). Nejjednodušší způsob určení oblasti je pomocí excelových rozsahů. Pokud např.~chceme načíst buňky od B5 po E17, nastavíme \texttt{range\ =\ "B5:E17"}. Sofistikovanější výběry jsou popsané v~dokumentaci k~balíku \textbf{cellranger}. Pokud rozsah zabere i~oblast ``prázdných buněk'', pak jsou chybějící hodnoty označeny jako~\texttt{NA}.

Funkce \texttt{read\_excel()} se v~ostatních ohledech chová podobně jako funkce \texttt{read\_csv()} z~balíku \textbf{readr}. První řádek výběru interpretuje funkce jako názvy sloupců. Pokud to nevyhovuje, je možné toto chování modifikovat pomocí parametru \texttt{col\_names}, jehož specifikace je stejná jako u~funkce \texttt{read\_csv()}.

Typy jednotlivých sloupců funkce \texttt{read\_excel()} odhaduje z~prvních 1~000~řádků dat. Pomocí parametru \texttt{col\_types} je však možné jednotlivé sloupce zadat, a~to jako vektor následujících řetězců: ``skip'', ``guess'', ``logical'', ``numeric'', ``date'', ``text'' a ``list''. První možnost sloupec přeskočí, druhá odhadne typ. Typ ``list'' vytvoří sloupec typu seznam (normálně je každý sloupec tabulky atomický vektor), což umožní, aby každá buňka sloupce mohla mít vlastní datový typ zjištěný z~dat. Ostatní typy mají očividný význam. Pokud je zadán právě jeden typ, R~jej recykluje a použije pro všechny sloupce.

Funkce umožňuje také přeskočit několik prvních řádků výběru pomocí parametru \texttt{skip}, načíst maximálně určitý počet řádků pomocí parametru \texttt{n\_max} a zadat, jaká hodnota z~excelového souboru se převede na hodnotu~\texttt{NA} v~R pomocí parametru \texttt{na}. Na další parametry funkce se podívejte do dokumentace.

Následující kód ukazuje příklad, jak funkce použít:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(readxl)}
\FunctionTok{excel\_sheets}\NormalTok{(}\StringTok{"data/reading\_and\_writing/FebPwtExport9292016.xlsx"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Preface"   "Data"      "Variables" "Regions"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{dt }\OtherTok{\textless{}{-}} \FunctionTok{read\_excel}\NormalTok{(}\StringTok{"data/reading\_and\_writing/FebPwtExport9292016.xlsx"}\NormalTok{,}
                 \AttributeTok{sheet =} \StringTok{"Data"}\NormalTok{,}
                 \AttributeTok{col\_types =} \FunctionTok{c}\NormalTok{(}\StringTok{"text"}\NormalTok{, }\StringTok{"text"}\NormalTok{, }\StringTok{"numeric"}\NormalTok{, }\StringTok{"numeric"}\NormalTok{))}
\FunctionTok{head}\NormalTok{(dt)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   VariableCode RegionCode YearCode AggValue
##   <chr>        <chr>         <dbl>    <dbl>
## 1 rgdpe        AGO            1970 29909.  
## 2 pop          AGO            1970     6.30
## 3 rgdpe        AGO            1980 32147.  
## 4 pop          AGO            1980     8.21
## 5 rgdpe        AGO            1990 34151.  
## 6 pop          AGO            1990    11.1
\end{verbatim}

Pokud je balík \textbf{readxl} nainstalován, pak RStudio umožňuje načíst excelové soubory pomocí interaktivního nástroje \texttt{Import\ Dataset} dostupného v~panelu \texttt{Environment}, viz levá část obrázku~\ref{fig:readxl-v-rstudiu}. Po jeho spuštění zvolte \texttt{From\ Excel...}. Nástroj umožňuje dokonce vybrat list a rozsah dat, nastavit jména sloupců a několik dalších věcí, viz pravá část obrázku~\ref{fig:readxl-v-rstudiu}. Nástroj opět vygeneruje kód, který je možné zkopírovat a vložit do skriptu.

\begin{figure}
\includegraphics[width=13.05in]{figs/readr/readxl_v_rstudiu} \caption{Načtení dat z Excelu v RStudiu.}\label{fig:readxl-v-rstudiu}
\end{figure}

Balík \textbf{readxl} zatím neumožňuje data do excelových souborů zapisovat. Pokud to potřebujete, podívejte se na balík \textbf{openxlsx}.

\hypertarget{data-z-jichuxfdch-statistickuxfdch-programux16f}{%
\section{Data z jichých statistických programů}\label{data-z-jichuxfdch-statistickuxfdch-programux16f}}

Někdy jsou data distribuovaná v~nativním formátu některého statistického softwaru. K~jejich načtení je možné použít balíky \textbf{haven} a \textbf{foregin}. Balík \textbf{haven} slouží k~načítání a ukládání souborů v~nativních formátech programů SPSS, SAS a Stata. Balík \textbf{foreign} umí načítat některé další datové formáty (a~do vybraných formátů i~zapisovat). Pokud nějaký formát umí číst oba balíky, doporučuji použít balík \textbf{haven}, na který se zde zaměříme. Jak se používá balík \textbf{foreign}, najdete v~jeho dokumentaci.

K~načítání dat poskytuje balík \textbf{haven} následující funkce: funkce \texttt{read\_dta()} a \texttt{read\_stata()} čtou soubory Stata DTA, funkce \texttt{read\_por()}, \texttt{read\_sav()} a \texttt{read\_spss()} čtou soubory SPSS POR a SAV a funkce \texttt{read\_xpt()} a \texttt{read\_sas()} čtou soubory SAS. Všechny tyto funkce vracejí načtená data jako tabulku třídy \emph{tibble}. Funkce \texttt{write\_dta}, \texttt{write\_sas}, \texttt{write\_sav} a \texttt{write\_xpt()} zapisují odpovídající formáty. Před jejich použitím je potřeba balík \textbf{haven} načíst; užitečné je zároveň načíst i~balík \textbf{labelled}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(haven)}
\FunctionTok{library}\NormalTok{(labelled)}
\end{Highlighting}
\end{Shaded}

Data pak načteme očekávávaným způsobem, kdy jméno souboru je prvním parametrem funkce \texttt{read\_xxx()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{dt }\OtherTok{\textless{}{-}} \FunctionTok{read\_spss}\NormalTok{(}\StringTok{"nama\_10\_gdp.sav"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Přitom mohou nastat dva problémy. První spočívá v~tom, že velké množství dat uložených v~těchto formátech zřejmě nebylo vytvořených přímo v~programech Stata, SPSS nebo SAS, nýbrž je vytvořily nějaké konvertory, které braly data z~databáze. Tyto konvertory často daný formát zcela nedodržují, takže vlastní software takto vytvořená data načte, ale balík \textbf{haven} si s~nimi neporadí. V~tom případě je potřeba načíst data do originálního softwaru (někdy stačí jeho svobodná obdoba, např.~pro software SPSS program PSPP) a data uložit do formátu CSV. Někdy také pomůže data znovu uložit do nativního formátu daného softwaru~-- balík \textbf{haven} si s~nimi potom poradí. Alternativně je možné vyzkoušet balík \textbf{foreign}. V některých případech uspěje tam, kde \textbf{haven} selhal.

Druhý problém spočívá v~tom, že všechny tři výše zmíněné programy používají poněkud jiné datové struktury než~R. Zejména se to týká ``popisků dat'' a kódování chybějících hodnot. Detaily rozdílů najdete ve vinětě balíku \textbf{haven} s~názvem ``Conversion semantics''. Zde se zaměříme pouze na popisky hodnot ve vektorech.
Stata, SPSS a další statistické programy umožňují ``přibalit'' k~proměnné (sloupci v~tabulce) nějaké dodatečné informace. Ukázkovým příkladem může být uchovávání dotazníkových dat. Předpokládejme, že respondenti odpovídali na následující otázku:

\begin{quote}
Máte rádi zpěv ve sprše?

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Určitě ano
\item
  Spíše ano
\item
  Spíše ne
\item
  Určitě ne
\end{enumerate}
\end{quote}

Samotná odpověď je typicky uložena jako číslo kódující odpověď nebo druh chybějící odpovědi (např.~``irelevantní'', nebo ``odmítl odpovědět'' a podobně). Význam těchto číselných kódů může být popsán právě v~těchto ``přibalených'' informacích. Ty často obsahují i~samotné znění otázky.
Balík \textbf{haven} převede při načítání dat sloupce s~přibalenými informacemi do třídy \textbf{labelled}. Balík zároveň implementuje i~základní funkce a metody pro práci s~daty této třídy; další funkce jsou obsaženy v~balíku \textbf{labelled}.

Vektor třídy \emph{labelled} je možné vytvořit i~uměle pomocí \texttt{labelled()} z~balíku \textbf{haven}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{lvector }\OtherTok{\textless{}{-}} \FunctionTok{labelled}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{1}\NormalTok{,}\DecValTok{2}\NormalTok{,}\DecValTok{3}\NormalTok{,}\DecValTok{1}\NormalTok{,}\DecValTok{4}\NormalTok{,}\SpecialCharTok{{-}}\DecValTok{99}\NormalTok{), }
                    \FunctionTok{c}\NormalTok{(}\StringTok{"Určitě ano"} \OtherTok{=} \DecValTok{1}\NormalTok{, }
                      \StringTok{"Spíše ano"} \OtherTok{=} \DecValTok{2}\NormalTok{, }
                      \StringTok{"Spíše ne"} \OtherTok{=} \DecValTok{3}\NormalTok{, }
                      \StringTok{"Určitě ne"} \OtherTok{=} \DecValTok{4}\NormalTok{, }
                      \StringTok{"Odmítl odpovědět"} \OtherTok{=} \SpecialCharTok{{-}}\DecValTok{99}\NormalTok{)}
\NormalTok{                    )}
\FunctionTok{class}\NormalTok{(lvector)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "haven_labelled" "vctrs_vctr"     "double"
\end{verbatim}

Po načtení jsou vektory této třídy součástí načtené tabulky. Zde si pro jednoduchost takovou tabulku vytvoříme ručně:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ltable }\OtherTok{\textless{}{-}}\NormalTok{ tibble}\SpecialCharTok{::}\FunctionTok{tibble}\NormalTok{(lvector)}
\FunctionTok{print}\NormalTok{(ltable)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 7 x 1
##                  lvector
##                <dbl+lbl>
## 1   1 [Určitě ano]      
## 2   1 [Určitě ano]      
## 3   2 [Spíše ano]       
## 4   3 [Spíše ne]        
## 5   1 [Určitě ano]      
## 6   4 [Určitě ne]       
## 7 -99 [Odmítl odpovědět]
\end{verbatim}

Číst informace z~``labels'' umožňují funkce \texttt{val\_labels()} a \texttt{var\_label()} z~balíku \textbf{labelled}. Funkce \texttt{var\_labels()} vrací ``labels'' přiřazené proměnné~-- tj.~celému sloupci (typicky znění otázky). \texttt{val\_labels()} vrací ``labels'' pro kódovací hodnoty v~tabulce:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{val\_labels}\NormalTok{(ltable)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $lvector
##       Určitě ano        Spíše ano         Spíše ne        Určitě ne 
##                1                2                3                4 
## Odmítl odpovědět 
##              -99
\end{verbatim}

Pro třídu \texttt{labelled} je v~R dostupné jen velmi málo metod. Proto bývá obvyklým krokem jejich konverze do jiného datové typu. Při této operaci je užitečné být opatrný. Pouhé odstranění ``lables'' totiž za sebou zanechá vektory celých čísel nebo tajemně kódovaných řetězců. K~touto účelu slouží funkce \texttt{zap\_labels()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{zap\_labels}\NormalTok{(ltable)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 7 x 1
##   lvector
##     <dbl>
## 1       1
## 2       1
## 3       2
## 4       3
## 5       1
## 6       4
## 7     -99
\end{verbatim}

Lepším způsobem je konverze kódovacích hodnot na faktor. K~tomu slouží funkce \texttt{as\_factor()}, která umí převést jeden vektor i~celou tabulku. Alternativně je možné popisky převést na faktor i~pomocí funkce \texttt{to\_factor()} nebo na vektor řetězců pomocí funkce \texttt{to\_character()} z~balíku \textbf{labelled}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{as\_factor}\NormalTok{(ltable)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 7 x 1
##   lvector         
##   <fct>           
## 1 Určitě ano      
## 2 Určitě ano      
## 3 Spíše ano       
## 4 Spíše ne        
## 5 Určitě ano      
## 6 Určitě ne       
## 7 Odmítl odpovědět
\end{verbatim}

Podobným způsobem je možné se vyrovnat i~s~různě kódovanými chybějícími hodnotami, viz viněta ``Conversion semantics''.

Pokud máte balík \textbf{haven} nainstalovaný, můžete v~RStudiu načítat data z~SPSS, SASu a Staty i~interaktivně, když v~záložce \texttt{Import\ Dataset} v~tabu \texttt{Environment} zvolíte \texttt{From\ SPSS...}, \texttt{From\ SAS...} nebo \texttt{From\ Stata...}, viz levá strana obrázku~\ref{fig:heaven-v-rstudiu}. Nástroj nemá žádná zvláštní nastavení, opět však vygeneruje kód, který můžete vložit do svého skriptu, viz , viz pravá strana obrázku~\ref{fig:heaven-v-rstudiu}.

\begin{figure}
\includegraphics[width=17.18in]{figs/readr/heaven_v_rstudiu} \caption{Načtení dat z SPSS, SAS a Stata v RStudiu.}\label{fig:heaven-v-rstudiu}
\end{figure}

\hypertarget{rychluxe1-cesta-k-datux16fm-baluxedk-rio}{%
\section{\texorpdfstring{Rychlá cesta k~datům: balík \textbf{rio}}{Rychlá cesta k~datům: balík rio}}\label{rychluxe1-cesta-k-datux16fm-baluxedk-rio}}

Pokud chcete rychle načíst data z~datového souboru (lokálního nebo na webu, nekomprimovaného nebo komprimovaného) a nepotřebujete mít důkladnou kontrolu nad zpracováním dat, můžete použít balík \textbf{rio}. Tento balík představuje wrapper nad balíky, které načítají data včetně balíků \textbf{readxl}, \textbf{haven}, \textbf{foreign} a mnoha dalších, takže umí načíst všechna data, která umí načíst funkce implementované v~těchto balících.
Balík implementuje především dvě funkce: \texttt{import()} a \texttt{export()}. Funkce \texttt{import()} načte data z~datového souboru a uloží je do proměnné třídy \emph{data.frame}. Funkce \texttt{export()} uloží data do datového souboru. Typ datového souboru odhadují obě funkce z~koncovky dat. Načítání a ukládání některých méně obvyklých formátů může vyžadovat doinstalování potřebných balíků. Seznam všech podporovaných formátů obsahuje viněta k~balíku.

Funkce \texttt{import()} vyžaduje nutně jen jeden parametr: cestu k~načítanému souboru. Pokud by se formát dat odhadl z~koncovky souboru špatně, umožňuje parametr \texttt{format} zadat typ dat ručně. Parametr \texttt{setclass} umožňuje změnit datovou strukturu, kterou funkce vrátí. Implicitně je to \emph{data.frame}, ale povolený je mimo jiné i~\emph{tibble}. Další parametry najdete v~dokumentaci k~funkci.
Funkce \texttt{export()} vyžaduje nutně jméno ukládané tabulky a jméno souboru včetně cesty. Další parametry opět najdete v~dokumentaci.

Několik příkladů použití:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(rio)}
\NormalTok{bmi }\OtherTok{\textless{}{-}} \FunctionTok{import}\NormalTok{(}\StringTok{"data/reading\_and\_writing/bmi\_data.csv.gz"}\NormalTok{)}
\NormalTok{chile }\OtherTok{\textless{}{-}} \FunctionTok{import}\NormalTok{(}\StringTok{"data/reading\_and\_writing/chile.dta"}\NormalTok{)}
\NormalTok{xls }\OtherTok{\textless{}{-}} \FunctionTok{import}\NormalTok{(}\StringTok{"data/reading\_and\_writing/FebPwtExport9292016.xlsx"}\NormalTok{)}
\FunctionTok{export}\NormalTok{(bmi, }\StringTok{"test.csv"}\NormalTok{)}
\FunctionTok{export}\NormalTok{(bmi, }\StringTok{"test.sav"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\hypertarget{kontrola-naux10dtenuxfdch-dat}{%
\section{Kontrola načtených dat}\label{kontrola-naux10dtenuxfdch-dat}}

Když načtete data ze souboru do paměti počítače, je obvykle moudré zkontrolovat, že se načetla všechna data, že se načetla správně a že znamenají to, co si myslíte. Vyplatí se projít minimálně těchto několik kroků:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\item
  Zkontrolujte, že má tabulka správný počet řádků (\texttt{nrow()}) a sloupců (\texttt{ncol()}), tj.~že se načetlo vše a nenačetl se nějaký ``odpad'' uložený na začátku nebo konci datového souboru.
\item
  Podívejte se na začátek (\texttt{head()}) a konec (\texttt{tail()}) tabulky; to opět pomůže zkontrolovat, zda se nenačetl nějaký zmatek na začátku nebo konci souboru a že vše vypadá tak, jak má.
\item
  Zkontrolujte strukturu tabulky (v~tabulce třídy \emph{tibble} vypsané nahoře, jinak pomocí funkce \texttt{str()})~-- jména sloupců, jejich typy a hodnoty.
\item
  Podívejte se na souhrnné statistiky dat (\texttt{summary()}): Jaké jsou hodnoty proměnných, zda dávají smysl a zda jsou správně velké. Porovnejte hodnoty s~tím, co víte odjinud. Zkontrolujte také, kde hodnoty chybí apod.
\end{enumerate}

\hypertarget{pruxe1ce-se-soubory-a-adresuxe1ux159i}{%
\chapter{Práce se soubory a adresáři}\label{pruxe1ce-se-soubory-a-adresuxe1ux159i}}

TODO

\hypertarget{part-pokroux10diluxe9-transformace-dat}{%
\part{Pokročilé transformace dat}\label{part-pokroux10diluxe9-transformace-dat}}

\hypertarget{kap:strings}{%
\chapter{Práce s řetězci}\label{kap:strings}}

Analýza dat nezahrnuje jen práci s~čísly, ale i~s~řetězci (texty). Když pomineme textovou analýzu jako takovou, velmi často jsou data zabalena v~textovém balastu a je třeba je z~něj extrahovat. R~má v~základním balíku \textbf{base} mnoho užitečných funkcí pro práci s~řetězci. Tyto funkce však mají často složité a vzájemně nekonzistenční rozhraní. Proto se zde místo nich podíváme na funkce implementované v~balíku \textbf{stringr} (a~také jednu funkci z~balíku \textbf{glue}), který výrazně zjednodušuje práci s~řetězci a stále pokrývá velkou většinu toho, co člověk potřebuje. (Balík \textbf{stringr} je uživatelsky přívětivý wrapper nad funkcemi balíku \textbf{stringi}; proto často vypisuje chyby ze \textbf{stringi} a stejně tak část dokumentace je třeba hledat ve \textbf{stringi}.)
Pro práci s~touto kapitolou je tedy nezbytné načíst balík \textbf{stringr} do paměti počítače:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(stringr)}
\end{Highlighting}
\end{Shaded}

Jména všech funkcí z~balíku \textbf{stringr} začínají \texttt{str\_}.

V~této kapitole se naučíte

\begin{itemize}
\tightlist
\item
  základy práce se řetězci
\item
  jak zjistit délku řetězce,
\item
  jak řetězce spojovat, duplikovat a zalamovat,
\item
  jak řetězce setřídit,
\item
  jak nahrazovat části řetězců,
\item
  jak pracovat s~regulárními výrazy a
\item
  jak měnit chování regulárních výrazů
\end{itemize}

a mnoho dalšího.

\hypertarget{zuxe1klady-ux159etux11bzce-v-r}{%
\section{Základy: řetězce v~R}\label{zuxe1klady-ux159etux11bzce-v-r}}

R ukládá řetězce ve vektorech datového typu \emph{character}.
Řetězec se zadává mezi dvěma uvozovkami nebo dvěma apostrofy. Uvozovky a apostrofy nejde míchat, ale je možné uzavřít apostrof mezi uvozovky nebo naopak:

\begin{Shaded}
\begin{Highlighting}[]
\StringTok{"Petr řekl: \textquotesingle{}Už tě nemiluji.\textquotesingle{}"}
\StringTok{\textquotesingle{}Agáta odpověděla: "Koho to zajímá?"\textquotesingle{}}
\end{Highlighting}
\end{Shaded}

Kromě uvozovek a apostrofů má v~řetězcích zvláštní význam i~zpětné lomítko \texttt{\textbackslash{}}. To slouží ke dvěma účelům: 1)~uvozuje speciální znaky jako např.~\texttt{"\textbackslash{}n"} (konec řádku), \texttt{"\textbackslash{}t"} (tabelátor) apod., a~2)~zbavuje speciální znaky jejich zvláštního významu. To provedeme tak, že zvláštnímu znaku předřadíme zpětné lomítko. Tímto způsobem je možné zbavit zvláštního významu i~uvozovky, apostrofy a zpětná lomítka a uvést je uvnitř řetězce:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s }\OtherTok{\textless{}{-}} \StringTok{"Petr na to odvětil: }\SpecialCharTok{\textbackslash{}"}\StringTok{Je to proto, že vypadáš jako }\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{.}\SpecialCharTok{\textbackslash{}"}\StringTok{"}
\end{Highlighting}
\end{Shaded}

Podobně můžete v~řetězcích zadat i~znaky Unicode pomocí \texttt{\textbackslash{}u} a příslušného čísla. Znak velká omega (\(\Omega\)) je např.~možné zadat jako \texttt{\textbackslash{}u03a9}. (Tabulku Unicode najdete na adrese \url{https://unicode-table.com/}.)

Funkce \texttt{print()}, která se používá při implicitním vypsání obsahu proměnné, vypisuje na začátku i~na konci řetězců uvozovky a všechny speciální znaky vypisuje se zpětnými lomítky. Pokud chcete vypsat řetězec ``normálně'', můžete použít funkci \texttt{cat()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(s)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Petr na to odvětil: \"Je to proto, že vypadáš jako \\.\""
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{cat}\NormalTok{(s)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Petr na to odvětil: "Je to proto, že vypadáš jako \."
\end{verbatim}

Kromě funkcí \texttt{print()} a \texttt{cat()} existuje mnoho dalších funkcí pro výpis řetězců. Nejvýznamnější z~nich uvádí tabulka~\ref{tab:strings-prints}. Na detaily použití těchto funkcí se podívejte do dokumentace.

\begin{longtable}[]{@{}ll@{}}
\caption{\label{tab:strings-prints} Vybrané funkce pro výpis řetězců.}\tabularnewline
\toprule
funkce & účel \\
\midrule
\endfirsthead
\toprule
funkce & účel \\
\midrule
\endhead
\texttt{print()} & generická funkce pro tisk objektů \\
\texttt{noquote()} & tisk bez uvozovek \\
\texttt{cat()} & tisk obsahu řetězců; spojuje více řetězců \\
\texttt{format()} & formátování proměnných před tiskem \\
\texttt{toString()} & konverze na řetězec \\
\texttt{sprintf()} & formátování řetězců ve stylu jazyka~C \\
\bottomrule
\end{longtable}

V~R~je potřeba rozlišovat mezi prázdným řetězcem (tj.~řetězcem \texttt{""}) a prázdným vektorem řetězců:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \StringTok{""}            \CommentTok{\# vektor délky 1 obsahující prázdný řetězec}
\FunctionTok{length}\NormalTok{(s1)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s2 }\OtherTok{\textless{}{-}} \FunctionTok{character}\NormalTok{(}\DecValTok{0}\NormalTok{)  }\CommentTok{\# vektor typu character, který má nulovou délku,}
\FunctionTok{length}\NormalTok{(s2)          }\CommentTok{\# tj. neobsahuje žádné řetězce}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 0
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s3 }\OtherTok{\textless{}{-}} \FunctionTok{character}\NormalTok{(}\DecValTok{5}\NormalTok{)  }\CommentTok{\# vektor pěti prázdných řetězců}
\FunctionTok{length}\NormalTok{(s3)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 5
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s3}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "" "" "" "" ""
\end{verbatim}

Všimněte si, že funkce \texttt{length()} vrací délku vektoru, ne délku řetězce, který vektor snad obsahuje.

R má dva speciální vektory, které obsahují písmena anglické abecedy:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{letters  }\CommentTok{\# malá písmena anglické abecedy}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{LETTERS  }\CommentTok{\# velká písmena anglické abecedy}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
## [20] "T" "U" "V" "W" "X" "Y" "Z"
\end{verbatim}

Pokud potřebujete porovnat, zda jsou dva řetězce stejné, můžete použít operátor~\texttt{==} i~funkci \texttt{all.equal()}. (Samozřejmě můžete použít i~\texttt{\textgreater{}}, \texttt{\textless{}} apod. pro zjištění, který řetězec by by byl umístěn ve slovníku dříve; později v~této kapitole však uvidíte funkce, které vám dají nad řazením řetězců větší kontrolu.)

\begin{Shaded}
\begin{Highlighting}[]
\StringTok{"abc"} \SpecialCharTok{==} \StringTok{"abc"}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\StringTok{"abc"} \SpecialCharTok{==} \StringTok{"ABC"}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{all.equal}\NormalTok{(}\StringTok{"abc"}\NormalTok{, }\StringTok{"abc"}\NormalTok{, }\StringTok{"abc"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Poznámka: Počítač dokáže zpracovávat jen sekvence jedniček a nul. Aby bylo jasné, jak binární čísla interpretovat jako text, musí být jasné kódování tohoto textu. Každý řetězec může mít v~R jiné kódování. Nativně umí R dvě kódování: ISO Latin~1 a UTF-8. Kromě toho zvládá i~nativní kódování operačního systému počítače, na kterém běží. Většinou se o~kódování nemusíte nijak starat. Problém může nastat jen v~případě přenosu dat mezi různými operačními systémy (v~rámci Windows i~mezi různými lokalizacemi). Naštěstí umí R změnit kódování i~převést text z~jednoho kódování do jiného. Pokud potřebujete data přenášet mezi počítači, zvažte použití standardního kódování UTF-8.
Základní dokumentaci ke kódování poskytuje \texttt{help("Encoding")}.
Ke konverzi kódování řetězců je možné použít funkci \texttt{iconv()} z~balíku \textbf{base} nebo funkci \texttt{str\_conv()} z~balíku \textbf{stringr}. Detaily použití obou funkcí najdete v~dokumentaci.

\hypertarget{zuxe1kladnuxed-operace}{%
\section{Základní operace}\label{zuxe1kladnuxed-operace}}

Nejdříve se podíváme na základní operace s~řetězci: na to, jak řetězce spojovat, třídit, replikovat, nahrazovat, srovnávat a zjišťovat jejich délku. Ve zbytku kapitoly se pak budeme věnovat pokročilejší práci s~řetězci pomocí regulárních výrazů.

\hypertarget{zjiux161tux11bnuxed-duxe9lky-ux159etux11bzce}{%
\subsection{Zjištění délky řetězce}\label{zjiux161tux11bnuxed-duxe9lky-ux159etux11bzce}}

Často potřebujeme zjistit délku jednotlivých řetězců. To nemůžeme udělat pomocí funkce \texttt{length()} protože ta nevrací délku řetězce, ale délku vektoru řetězců. Nebude to fungovat ani v~případě jediného řetězce, protože i~to je vektor o~délce~1. (Pamatujte, že R~nemá skalár: to, co vypadá jako jeden řetězec, je ve skutečnosti vektor řetězců o~délce~1.)

Ke zjištění délky řetězce slouží funkce \texttt{str\_length()}, která vrací vektor délek jednotlivých řetězců ve vektoru:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \StringTok{"Ahoj!"}
\NormalTok{s2 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"A"}\NormalTok{, }\StringTok{"Bb"}\NormalTok{, }\StringTok{"Ccc"}\NormalTok{, }\ConstantTok{NA}\NormalTok{)}
\FunctionTok{length}\NormalTok{(s1)  }\CommentTok{\# délka (= počet prvků) vektoru s1}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{length}\NormalTok{(s2)  }\CommentTok{\# délka (= počet prvků) vektoru s2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_length}\NormalTok{(s1)  }\CommentTok{\# vektor délek (= počtu znaků) řetězce s1}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 5
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_length}\NormalTok{(s2)  }\CommentTok{\# vektor délek (= počtu znaků) řetězců ve vektoru s2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  1  2  3 NA
\end{verbatim}

Pozor: Technicky vzato vrací funkce \texttt{str\_length()} počet tzv.~``code points''. Ty většinou odpovídají jednotlivým znakům, ne však vždy. Např.~znak~\texttt{á} může být v~paměti počítače reprezentován jako jeden znak nebo dva znaky (\texttt{a} a akcent). Ve druhém případě vrátí funkce \texttt{str\_length()} délku~2. V~takovém případě je bezpečnější počítat počet znaků pomocí funkce \texttt{str\_count()}, viz dále. Příklad najdete v~dokumentaci funkce. Pokud jsou však anglické i~české znaky zadané obvyklým způsobem, pak bude funkce \texttt{str\_length()} vracet počet znaků v~jednotlivých řetězcích.

\hypertarget{spojenuxed-ux159etux11bzcux16f}{%
\subsection{Spojení řetězců}\label{spojenuxed-ux159etux11bzcux16f}}

Ke spojení více řetězců do jednoho slouží funkce \texttt{str\_c(...,\ sep\ =\ "",\ collapse\ =\ NULL)}. Funkce bere libovolný počet řetězců, vypustí z~nich prázdné vektory řetězců a \texttt{NULL} (ale ne prázdné řetězce \texttt{""}) a zbylé řetězce spojí do jednoho řetězce. Funkce \texttt{str\_c()} implicitně odděluje jednotlivé řetězce prázdným řetězcem, tj.~spojí jednotlivé řetězce těsně za sebe. Oddělovací řetězec je možné nastavit pomocí pojmenovaného parametru \texttt{sep}. (Všimněte si, že prázdný řetězec \texttt{""} funkce nevypustila.)

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_c}\NormalTok{(}\StringTok{"Jednou"}\NormalTok{, }\StringTok{""}\NormalTok{, }\StringTok{"budem"}\NormalTok{, }\FunctionTok{character}\NormalTok{(}\DecValTok{0}\NormalTok{), }\StringTok{"možná"}\NormalTok{, }\ConstantTok{NULL}\NormalTok{, }\StringTok{"dál!"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Jednoubudemmožnádál!"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_c}\NormalTok{(}\StringTok{"Jednou"}\NormalTok{, }\StringTok{""}\NormalTok{, }\StringTok{"budem"}\NormalTok{, }\FunctionTok{character}\NormalTok{(}\DecValTok{0}\NormalTok{), }\StringTok{"možná"}\NormalTok{, }\ConstantTok{NULL}\NormalTok{, }\StringTok{"dál!"}\NormalTok{, }\AttributeTok{sep =} \StringTok{" "}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Jednou  budem možná dál!"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_c}\NormalTok{(}\StringTok{"Jednou"}\NormalTok{, }\StringTok{""}\NormalTok{, }\StringTok{"budem"}\NormalTok{, }\FunctionTok{character}\NormalTok{(}\DecValTok{0}\NormalTok{), }\StringTok{"možná"}\NormalTok{, }\ConstantTok{NULL}\NormalTok{, }\StringTok{"dál!"}\NormalTok{, }\AttributeTok{sep =} \StringTok{"{-}"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Jednou--budem-možná-dál!"
\end{verbatim}

Někdy potřebujeme spojit vektory řetězců. Funkce \texttt{str\_c()} spojí odpovídající prvky jednotlivých vektorů (s~obvyklou recyklací kratších vektorů, při které funkce vypíše varování) a vrátí vektor (rozumnější použití uvidíte dále):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{, }\StringTok{"d"}\NormalTok{)}
\NormalTok{s2 }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{3}  \CommentTok{\# automatická koerze převede čísla na řetězce}
\FunctionTok{str\_c}\NormalTok{(s1, s2)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning in stri_c(..., sep = sep, collapse = collapse, ignore_null = TRUE):
## longer object length is not a multiple of shorter object length
\end{verbatim}

\begin{verbatim}
## [1] "a1" "b2" "c3" "d1"
\end{verbatim}

Pokud navíc chceme výsledný vektor spojit do jednoho řetězce, můžeme použít parametr \texttt{collapse}, kterým se nastavuje řetězec oddělující jednotlivé dílčí vektory (funguje i~prázdný řetězec~\texttt{""}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_c}\NormalTok{(s1, s2, }\AttributeTok{collapse =} \StringTok{"{-}"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning in stri_c(..., sep = sep, collapse = collapse, ignore_null = TRUE):
## longer object length is not a multiple of shorter object length
\end{verbatim}

\begin{verbatim}
## [1] "a1-b2-c3-d1"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_c}\NormalTok{(s1, s2, }\AttributeTok{collapse =} \StringTok{""}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning in stri_c(..., sep = sep, collapse = collapse, ignore_null = TRUE):
## longer object length is not a multiple of shorter object length
\end{verbatim}

\begin{verbatim}
## [1] "a1b2c3d1"
\end{verbatim}

Celkově funguje funkce \texttt{str\_c()} takto: své parametry chápe jako vektory řetězců. Tyto vektory sestaví do matice, kde každý vstupní vektor tvoří jeden sloupec této matice (přitom prodlouží kratší vektory recyklací jeho prvků). Pak vloží mezi jednotlivé sloupce řetězec \texttt{sep} a spojí každý řádek do jednoho řetězce, takže výsledkem je jeden vektor řetězců. Pokud je navíc zadán řetězec \texttt{collapse} (tj.~není~\texttt{NULL}), funkce vloží tento řetězec mezi jednotlivé prvky tohoto vektoru a spojí je do jednoho řetězce. Tabulka~\ref{tab:strings-strc} ukazuje, co udělá výraz \texttt{str\_c(s1,\ s2,\ sep\ =\ "-")}.

\begin{longtable}[]{@{}llll@{}}
\caption{\label{tab:strings-strc} Ukázka toho, jak funguje výraz \texttt{str\_c(s1,\ s2,\ sep\ =\ "-")}.}\tabularnewline
\toprule
\texttt{s1} & (sep) & \texttt{s2} & výsledek \\
\midrule
\endfirsthead
\toprule
\texttt{s1} & (sep) & \texttt{s2} & výsledek \\
\midrule
\endhead
a & - & 1 & a-1 \\
b & - & 2 & b-2 \\
c & - & 3 & c-3 \\
d & - & 1 & d-1 \\
\bottomrule
\end{longtable}

Pokud má kterýkoli řetězec ve spojovaných vektorech hodnotu \texttt{NA}, pak je výsledné spojení také \texttt{NA}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\ConstantTok{NA}\NormalTok{)}
\NormalTok{s2 }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\DecValTok{3}
\FunctionTok{str\_c}\NormalTok{(s1, s2)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "a1" "b2" NA
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_c}\NormalTok{(s1, s2, }\AttributeTok{collapse =} \StringTok{"{-}"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] NA
\end{verbatim}

Některé zajímavé příklady použití funkce \texttt{str\_c()} jsme vybrali z~dokumentace funkce:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_c}\NormalTok{(}\StringTok{"Letter"}\NormalTok{, letters, }\AttributeTok{sep =} \StringTok{": "}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "Letter: a" "Letter: b" "Letter: c" "Letter: d" "Letter: e" "Letter: f"
##  [7] "Letter: g" "Letter: h" "Letter: i" "Letter: j" "Letter: k" "Letter: l"
## [13] "Letter: m" "Letter: n" "Letter: o" "Letter: p" "Letter: q" "Letter: r"
## [19] "Letter: s" "Letter: t" "Letter: u" "Letter: v" "Letter: w" "Letter: x"
## [25] "Letter: y" "Letter: z"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_c}\NormalTok{(letters[}\SpecialCharTok{{-}}\DecValTok{26}\NormalTok{], }\StringTok{" comes before "}\NormalTok{, letters[}\SpecialCharTok{{-}}\DecValTok{1}\NormalTok{])}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "a comes before b" "b comes before c" "c comes before d" "d comes before e"
##  [5] "e comes before f" "f comes before g" "g comes before h" "h comes before i"
##  [9] "i comes before j" "j comes before k" "k comes before l" "l comes before m"
## [13] "m comes before n" "n comes before o" "o comes before p" "p comes before q"
## [17] "q comes before r" "r comes before s" "s comes before t" "t comes before u"
## [21] "u comes before v" "v comes before w" "w comes before x" "x comes before y"
## [25] "y comes before z"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_c}\NormalTok{(letters, }\AttributeTok{collapse =} \StringTok{", "}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z"
\end{verbatim}

\hypertarget{doplnux11bnuxed-hodnot-do-ux159etux11bzcux16f}{%
\subsection{Doplnění hodnot do řetězců}\label{doplnux11bnuxed-hodnot-do-ux159etux11bzcux16f}}

Někdy potřebujeme spojit několik řetězců tak, že na vybraná místa do textu ``vlepíme'' hodnoty z~vybraných proměnných~-- např.~když chceme sestavit výpis z~účtu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{cislo\_uctu }\OtherTok{\textless{}{-}} \DecValTok{854397}
\NormalTok{zustatek }\OtherTok{\textless{}{-}} \FloatTok{12365.30}
\FunctionTok{str\_c}\NormalTok{(}\StringTok{"Na účtu číslo "}\NormalTok{, cislo\_uctu, }\StringTok{" je aktuální zůstatek "}\NormalTok{,}
      \FunctionTok{format}\NormalTok{(zustatek, }\AttributeTok{big.mark =} \StringTok{"."}\NormalTok{, }\AttributeTok{decimal.mark =} \StringTok{","}\NormalTok{, }\AttributeTok{nsmall =} \DecValTok{2}\NormalTok{),}
      \StringTok{" Kč."}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Na účtu číslo 854397 je aktuální zůstatek 12.365,30 Kč."
\end{verbatim}

Využít ke ``vlepení'' hodnot do řetězce funkci \texttt{str\_c()}, jak to ukazuje výše uvedený příklad, je možné, ale výsledek není právě přehledný. Místo toho můžeme použít speciální funkci \texttt{glue()} z~balíku \textbf{glue}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(glue)}
\NormalTok{hezky\_zustatek }\OtherTok{\textless{}{-}} \FunctionTok{format}\NormalTok{(zustatek, }\AttributeTok{big.mark =} \StringTok{\textquotesingle{}.\textquotesingle{}}\NormalTok{,}
                                \AttributeTok{decimal.mark =} \StringTok{\textquotesingle{},\textquotesingle{}}\NormalTok{, }\AttributeTok{nsmall =} \DecValTok{2}\NormalTok{)}
\FunctionTok{glue}\NormalTok{(}\StringTok{"Na účtu číslo \{cislo\_uctu\} je aktualni zustatek \{hezky\_zustatek\} Kč."}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Na účtu číslo 854397 je aktualni zustatek 12.365,30 Kč.
\end{verbatim}

Funkce \texttt{glue()} vezme jeden nebo více řetězců, slepí je dohromady a na místa ve složených závorkách vloží hodnoty proměnných z~aktuálního prostředí~R, přesněji výsledek výpočtu, takže předchozí kód bychom mohli napsat i~takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{glue}\NormalTok{(}\StringTok{"Na účtu číslo \{cislo\_uctu\} je aktualni zustatek "}\NormalTok{,}
     \StringTok{"\{format(zustatek, big.mark = \textquotesingle{}.\textquotesingle{}, decimal.mark = \textquotesingle{},\textquotesingle{}, nsmall = 2)\} Kč."}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Na účtu číslo 854397 je aktualni zustatek 12.365,30 Kč.
\end{verbatim}

Hodnoty vložených proměnných můžeme zadat přímo jako parametry funkce \texttt{glue()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{glue}\NormalTok{(}\StringTok{"Na účtu číslo \{cislo\_uctu\} je aktualni zustatek \{zustatek\} Kč."}\NormalTok{,}
     \AttributeTok{cislo\_uctu =} \DecValTok{24683}\NormalTok{, }\AttributeTok{zustatek =} \DecValTok{123}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Na účtu číslo 24683 je aktualni zustatek 123 Kč.
\end{verbatim}

Funkce \texttt{glue()} má několik zajímavých vlastností: zahazuje počáteční a koncová bílá místa (mezery apod.) včetně prvního a posledního zalomení řádku, ostatní zalomení a mezery však respektuje:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{glue}\NormalTok{(}\StringTok{"}
\StringTok{   Toto je jakýsi text.}
\StringTok{        A zde pokračuje...}
\StringTok{     "}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Toto je jakýsi text.
##      A zde pokračuje...
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{glue}\NormalTok{(}\StringTok{"}

\StringTok{   Toto je jakýsi text.}
\StringTok{        A zde pokračuje...}

\StringTok{        "}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
## Toto je jakýsi text.
##      A zde pokračuje...
\end{verbatim}

Zalomení řádků je možné zabránit pomocí (zdvojeného) lomítka na jeho konci:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{glue}\NormalTok{(}\StringTok{"Zde nějaký text začíná, }\SpecialCharTok{\textbackslash{}\textbackslash{}}
\StringTok{     a zde pokračuje."}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Zde nějaký text začíná, a zde pokračuje.
\end{verbatim}

Pokud z~nějakého důvodu potřebujeme v~textu použít složené závorky, máme dvě možnosti: buď je zdvojit, nebo pomocí parametrů \texttt{.open} a \texttt{.close} nastavit jiný počátek a konec nahrazované oblasti na jiný znak:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{glue}\NormalTok{(}\StringTok{"Zde je \{\{jméno\}\}."}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Zde je {jméno}.
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{glue}\NormalTok{(}\StringTok{"Jméno výherce soutěže je \{}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{bf \textless{}\textless{}name\textgreater{}\textgreater{}\}."}\NormalTok{, }\AttributeTok{.open =} \StringTok{"\textless{}\textless{}"}\NormalTok{, }\AttributeTok{.close =}\StringTok{"\textgreater{}\textgreater{}"}\NormalTok{,}
     \AttributeTok{name =} \StringTok{"Joe"}\NormalTok{) }\CommentTok{\# vhodné např. při exportu do LaTeXu}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Jméno výherce soutěže je {\bf Joe}.
\end{verbatim}

Balík \textbf{stringr} nabízí podobnou funkcionalitu ve funkcích \texttt{str\_glue()} a \texttt{str\_interp()}. Funkce \texttt{str\_glue()} je vpodstatě jen wrapper nad funkcí \texttt{glue()} a používá se stejně:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_glue}\NormalTok{(}\StringTok{"Jmenuji se \{name\} a příští rok mi bude \{age + 1\} let."}\NormalTok{,}
         \AttributeTok{name =} \StringTok{"Jana"}\NormalTok{, }\AttributeTok{age =} \DecValTok{40}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Jmenuji se Jana a příští rok mi bude 41 let.
\end{verbatim}

Naproti tomu funkce \texttt{str\_interp()} má poněkud jiné použití. V~jejím případě musí mít nahrazovaný text buď podobu \texttt{\$\{\}}, kde ve složených závorkách je nějaký výraz, nebo \texttt{\${[}{]}\{\}}, kde v~hranatých závorkách je formát a v~složených výraz. Formát určuje typicky formátování čísel~-- např.~\texttt{.2f} znamená, že se vytisknou dvě desetinná místa (detaily formátu viz nápověda k~funkci \texttt{sprintf()}). Pokud chceme zadat vkládané hodnoty přímo v~této funkci, je třeba je zabalit do seznamu.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_interp}\NormalTok{(}\StringTok{"Na účtu číslo $\{cislo\_uctu\} je aktualni zustatek $\{zustatek\} Kč."}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Na účtu číslo 854397 je aktualni zustatek 12365.3 Kč."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_interp}\NormalTok{(}\StringTok{"Na účtu číslo $[d]\{cislo\_uctu\} je aktualni zustatek $[.2f]\{zustatek\} Kč."}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Na účtu číslo 854397 je aktualni zustatek 12365.30 Kč."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_interp}\NormalTok{(}\StringTok{"Na účtu číslo $[d]\{cislo\_uctu\} je aktualni zustatek $[.2f]\{zustatek\} Kč."}\NormalTok{,}
           \FunctionTok{list}\NormalTok{(}\AttributeTok{cislo\_uctu =} \DecValTok{51349}\NormalTok{, }\AttributeTok{zustatek =} \DecValTok{17}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Na účtu číslo 51349 je aktualni zustatek 17.00 Kč."
\end{verbatim}

\hypertarget{ux159azenuxed-ux159etux11bzcux16f}{%
\subsection{Řazení řetězců}\label{ux159azenuxed-ux159etux11bzcux16f}}

Pro setřídění řetězců většinou stačí základní funkce \texttt{sort()} a \texttt{order()}. Pro složitější případy, kdy je např.~třeba třídit v~cizím \emph{locale}, nabízí balík \textbf{stringr} dvě funkce:

\begin{itemize}
\item
  \texttt{str\_order(x,\ decreasing\ =\ FALSE,\ na\_last\ =\ TRUE,\ locale\ =\ "en",\ numeric\ =\ FALSE,\ ...)} vrací celé číslo, které odpovídá pořadí daného řetězce ve vektoru~\texttt{x} (podobně jako funkce \texttt{order()})
\item
  \texttt{str\_sort(x,\ decreasing\ =\ FALSE,\ na\_last\ =\ TRUE,\ locale\ =\ "en",\ numeric\ =\ FALSE,\ ...)} setřídí vektor řetězců~\texttt{x}
\end{itemize}

Přitom \texttt{x} je vektor řetězců, který má být setříděn. \texttt{decreasing} je logická hodnota (implicitní hodnota je \texttt{FALSE}; pak třídí od nejnižšího k~nejvyššímu; \texttt{TRUE} třídí od nejvyššího k~nejnižšímu). \texttt{na\_last} je logická hodnota (implicitní hodnota je \texttt{TRUE}, při které funkce umístí hodnoty \texttt{NA} na konec vektoru; \texttt{FALSE} je umístí na začátek na začátek vektoru; \texttt{NA} je vyhodí). \texttt{locale} označuje v~jakém \emph{locale} se má třídit (implicitně v~systémovém). Pokud je logická hodnota \texttt{numeric} nastavena na \texttt{TRUE}, pak číslice řadí jako čísla, ne jako řetězce; implicitní hodnota je \texttt{FALSE}. \texttt{...} označují další parametry přidané do \texttt{stri\_opts\_collator}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_order}\NormalTok{(letters, }\AttributeTok{locale =} \StringTok{"en"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [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
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sort}\NormalTok{(letters, }\AttributeTok{locale =} \StringTok{"en"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"
\end{verbatim}

\hypertarget{vuxfdbux11br-a-nuxe1hrada-pomocuxed-indexux16f}{%
\subsection{Výběr a náhrada pomocí indexů}\label{vuxfdbux11br-a-nuxe1hrada-pomocuxed-indexux16f}}

Někdy je třeba z~řetězce vybrat jeho část. Pokud známe pozici prvního a posledního znaku, který chceme vybrat, můžeme použít funkce \texttt{str\_sub(string,\ start\ =\ 1L,\ end\ =\ -1L)}, kde \texttt{string} je řetězec, ze kterého vybíráme, \texttt{start} je pozice znaku začátku výběru a \texttt{end} je pozice konce výběru (včetně). Implicitní hodnota \texttt{start} je~1 (tj.~od začátku vektoru), implicitní hodnota \texttt{end} je~\(-1\) (tj.~do konce vektoru). Pozice znaků mohou být zadány i~jako záporná čísla~-- ta se počítají od konce vektoru, takže např.~\(-1\) je poslední znak vektoru.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \StringTok{"Sol 6: Katastrofa na Marsu."}
\FunctionTok{str\_sub}\NormalTok{(s1, }\AttributeTok{start =} \DecValTok{8}\NormalTok{, }\AttributeTok{end =} \FunctionTok{str\_length}\NormalTok{(s1))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Katastrofa na Marsu."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sub}\NormalTok{(s1, }\AttributeTok{start =} \DecValTok{8}\NormalTok{, }\AttributeTok{end =} \SpecialCharTok{{-}}\DecValTok{1}\NormalTok{)  }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Katastrofa na Marsu."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sub}\NormalTok{(s1, }\DecValTok{8}\NormalTok{)  }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Katastrofa na Marsu."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sub}\NormalTok{(s1, }\AttributeTok{end =} \DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Sol 6"
\end{verbatim}

Funkce \texttt{str\_sub()} recykluje všechny své parametry. Pokud chceme např.~vybrat stejné pozice z~každého vektoru v řetězci:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s2 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(s1, }\StringTok{"Sol 7: Nová naděje."}\NormalTok{)}
\FunctionTok{str\_sub}\NormalTok{(s2, }\AttributeTok{start =} \FunctionTok{c}\NormalTok{(}\DecValTok{8}\NormalTok{, }\DecValTok{8}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Katastrofa na Marsu." "Nová naděje."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sub}\NormalTok{(s2, }\DecValTok{8}\NormalTok{)  }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Katastrofa na Marsu." "Nová naděje."
\end{verbatim}

Stejně tak je však možné recyklovat i~řetězec a vybrat z~něj naráz dva pod-řetězce:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sub}\NormalTok{(s1, }\AttributeTok{start =} \FunctionTok{c}\NormalTok{(}\DecValTok{8}\NormalTok{, }\DecValTok{22}\NormalTok{), }\AttributeTok{end =} \FunctionTok{c}\NormalTok{(}\DecValTok{17}\NormalTok{, }\DecValTok{26}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Katastrofa" "Marsu"
\end{verbatim}

Pokud je řetěz kratší než výběr znaků, vrátí funkce \texttt{str\_sub()} tolik znaků, kolik může (někdy i~prázdný řetězec):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sub}\NormalTok{(s1, }\AttributeTok{start =} \DecValTok{25}\NormalTok{, }\AttributeTok{end =} \DecValTok{50}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "su."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sub}\NormalTok{(s1, }\AttributeTok{start =} \DecValTok{40}\NormalTok{, }\AttributeTok{end =} \DecValTok{50}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] ""
\end{verbatim}

Funkci \texttt{str\_sub()} je možné použít i~k~náhradě části řetězce:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sub}\NormalTok{(s1, }\DecValTok{22}\NormalTok{, }\DecValTok{26}\NormalTok{) }\OtherTok{\textless{}{-}} \StringTok{"rudé planetě"}
\NormalTok{s1}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Sol 6: Katastrofa na rudé planetě."
\end{verbatim}

\hypertarget{replikace-ux159etux11bzcux16f}{%
\subsection{Replikace řetězců}\label{replikace-ux159etux11bzcux16f}}

Někdy je potřeba nějaký řetězec ``zmnožit''. K~tomu slouží funkce \texttt{str\_dup(string,\ times)}, který vezme vektor~\texttt{string}, zopakuje jej \texttt{times}-krát a výsledek spojí. To se hodí např.~při načítání mnoha textových sloupců pomocí balíku \textbf{readr}. Při tom je někdy užitečné říct funkci \texttt{read\_csv()}, že všechny sloupce tabulky mají typ \texttt{character}. K~tomu slouží řetězec mnoha ``c'':

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_dup}\NormalTok{(}\StringTok{"c"}\NormalTok{, }\DecValTok{28}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "cccccccccccccccccccccccccccc"
\end{verbatim}

Funkce \texttt{str\_dup()} také recykluje všechny své parametry:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_dup}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{), }\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "a"   "bb"  "ccc"
\end{verbatim}

\hypertarget{odstranux11bnuxed-okrajovuxfdch-mezer}{%
\subsection{Odstranění okrajových mezer}\label{odstranux11bnuxed-okrajovuxfdch-mezer}}

Někdy dostaneme řetězec, který začíná nebo končí ``bílými znaky'' (mezerami, tabelátory, novými řádky ``\texttt{\textbackslash{}n}'' apod.). Tato situace vznikne např.~tehdy, když řetězec vznikl rozdělením delšího řetězce na části. Tyto bílé znaky je často vhodné odstranit. K~tomu slouží funkce \texttt{str\_trim(string,\ side)}, kde \texttt{string}~je řetězec a \texttt{side} označuje stranu, ze které se mají bílé znaky odstranit:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"Ahoj,"}\NormalTok{, }\StringTok{" lidi, "}\NormalTok{, }\StringTok{"jak "}\NormalTok{, }\StringTok{"se"}\NormalTok{, }\StringTok{" máte?"}\NormalTok{)}
\FunctionTok{str\_trim}\NormalTok{(s1, }\StringTok{"left"}\NormalTok{)   }\CommentTok{\# odstraní mezery zleva}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Ahoj,"  "lidi, " "jak "   "se"     "máte?"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_trim}\NormalTok{(s1, }\StringTok{"right"}\NormalTok{)  }\CommentTok{\# odstraní mezery zprava}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Ahoj,"  " lidi," "jak"    "se"     " máte?"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_trim}\NormalTok{(s1, }\StringTok{"both"}\NormalTok{)   }\CommentTok{\# odstraní mezery z obou stran}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Ahoj," "lidi," "jak"   "se"    "máte?"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_trim}\NormalTok{(s1)   }\CommentTok{\# totéž {-}{-} "both" je implicitní hodnota side}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Ahoj," "lidi," "jak"   "se"    "máte?"
\end{verbatim}

Funkce \texttt{str\_squish(string)} funguje podobně, ale odstraní navíc i~všechny přebytečné prázdné znaky~-- na začátku řetězce \texttt{string}, na jeho konci i~opakované znaky uvnitř:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_squish}\NormalTok{(}\StringTok{"  Toto  je   koktavý  text.   "}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Toto je koktavý text."
\end{verbatim}

\hypertarget{zarovnuxe1nuxed-a-oux159eux17e-ux159etux11bzcux16f-na-stejnou-duxe9lku-a-do-odstavce}{%
\subsection{Zarovnání a ořež řetězců na stejnou délku a do odstavce}\label{zarovnuxe1nuxed-a-oux159eux17e-ux159etux11bzcux16f-na-stejnou-duxe9lku-a-do-odstavce}}

Někdy je užitečné zarovnat řetězce na stejnou délku přidáním bílých (nebo jiných) znaků. K~tomu slouží funkce \texttt{str\_pad(string,\ width,\ side,\ pad\ =\ "\ ")}, kde \texttt{string} je vektor zarovnávaných řetězců, \texttt{width} je minimální délka výsledného řetězce, \texttt{side} je strana, na kterou se mají výplňové znaky přidat (implicitně je to \texttt{left}) a \texttt{pad} je výplňový řetězec (implicitně mezera).

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_pad}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"Ahoj"}\NormalTok{, }\StringTok{"lidi"}\NormalTok{), }\DecValTok{7}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "   Ahoj" "   lidi"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_pad}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"Ahoj"}\NormalTok{, }\StringTok{"lidi"}\NormalTok{), }\DecValTok{9}\NormalTok{, }\AttributeTok{side =} \StringTok{"both"}\NormalTok{, }\AttributeTok{pad =} \StringTok{"{-}"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "--Ahoj---" "--lidi---"
\end{verbatim}

Delší řetězce funkce nemění:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_pad}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"Ahoj"}\NormalTok{, }\StringTok{"malé zelené bytosti z Viltvodlu VI"}\NormalTok{), }\AttributeTok{width =} \DecValTok{7}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "   Ahoj"                            "malé zelené bytosti z Viltvodlu VI"
\end{verbatim}

V~některých případech potřebujeme delší řetězec zkrátit na určitou délku tak, že se jeho část vynechá. K~tomu slouží funkce \texttt{str\_trunc(string,\ width,\ side\ =\ c("right",\ "left",\ "center"),\ ellipsis\ =\ "...")}, která zkrátí řetězec \texttt{string} na délku \texttt{width} znaků. Přitom přebytečnou část textu na straně \texttt{side} vynechá a nahradí znaky \texttt{ellipsis}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s }\OtherTok{\textless{}{-}} \StringTok{"Toto je přehnaně dlouhý text, který toho mnoho neříká."}
\FunctionTok{str\_trunc}\NormalTok{(s, }\DecValTok{20}\NormalTok{, }\StringTok{"right"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Toto je přehnaně ..."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_trunc}\NormalTok{(s, }\DecValTok{20}\NormalTok{, }\StringTok{"left"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "...oho mnoho neříká."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_trunc}\NormalTok{(s, }\DecValTok{20}\NormalTok{, }\StringTok{"center"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Toto je p... neříká."
\end{verbatim}

Zarovnat řetězec do odstavce umožňuje funkce \texttt{str\_wrap(string,\ width\ =\ 80,\ indent\ =\ 0,\ exdent\ =\ 0)}, kde \texttt{strings} je zarovnávaný řetězec, \texttt{width} je cílová šířka sloupce (implicitně~80 znaků), \texttt{indent} je odsazení prvního řádku a \texttt{exdent} je odsazení následujících řádků (oboje implicitně 0~znaků):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \StringTok{"Na počátku bylo Slovo, to Slovo bylo u Boha, to Slovo byl Bůh. To bylo na počátku u Boha. Všechno povstalo skrze ně a bez něho nepovstalo nic, co jest. V něm byl život a život byl světlo lidí. To světlo ve tmě svítí a tma je nepohltila."}
\FunctionTok{cat}\NormalTok{(}\FunctionTok{str\_wrap}\NormalTok{(s1, }\DecValTok{60}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Na počátku bylo Slovo, to Slovo bylo u Boha, to Slovo byl
## Bůh. To bylo na počátku u Boha. Všechno povstalo skrze ně
## a bez něho nepovstalo nic, co jest. V něm byl život a život
## byl světlo lidí. To světlo ve tmě svítí a tma je nepohltila.
\end{verbatim}

\hypertarget{konverze-maluxfdch-a-velkuxfdch-puxedsmen}{%
\subsection{Konverze malých a velkých písmen}\label{konverze-maluxfdch-a-velkuxfdch-puxedsmen}}

Ke konverzi malých písmen na velká slouží funkce \texttt{str\_to\_upper(string,\ locale\ =\ "en")}, ke konverzi na malá písmena funkce \texttt{str\_to\_lower(string,\ locale\ =\ "en")}, kde \texttt{string} je převáděný řetězec. Parametr \texttt{locale} umožňuje zadat popis jazykových pravidel pro převod znaků. Parametr je nepovinný a pokud není zadán, použije se aktuální \emph{locale} počítače.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s }\OtherTok{\textless{}{-}} \StringTok{"Nějaký malý textík..."}
\FunctionTok{str\_to\_lower}\NormalTok{(s, }\AttributeTok{locale =} \StringTok{"cz"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "nějaký malý textík..."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_to\_upper}\NormalTok{(s, }\AttributeTok{locale =} \StringTok{"cz"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "NĚJAKÝ MALÝ TEXTÍK..."
\end{verbatim}

\hypertarget{nahrazenuxed-chybux11bjuxedcuxedch-hodnot-ux159etux11bzcem}{%
\subsection{Nahrazení chybějících hodnot řetězcem}\label{nahrazenuxed-chybux11bjuxedcuxedch-hodnot-ux159etux11bzcem}}

Někdy máme vektor řetězců, ve kterém některé hodnoty chybí, tj.~mají hodnotu~\texttt{NA}, a~my potřebujeme tyto hodnoty nahradit nějakým textem. K~tomu slouží funkce \texttt{str\_replace\_na(string,\ replacement\ =\ "NA")}, kde \texttt{string} je vektor řetězců a \texttt{replacement} je řetězec, který má v~řetězci \texttt{string} nahradit chybějící hodnoty. Pokud chceme např.~nahradit chybějící hodnoty slovem ``neznámé'', můžeme to udělat takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{poloha }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"nahoře"}\NormalTok{, }\StringTok{"dole"}\NormalTok{, }\ConstantTok{NA}\NormalTok{, }\StringTok{"vlevo"}\NormalTok{)}
\FunctionTok{str\_replace\_na}\NormalTok{(poloha, }\AttributeTok{replacement =} \StringTok{"neznámá"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "nahoře"  "dole"    "neznámá" "vlevo"
\end{verbatim}

\hypertarget{formuxe1tovuxe1nuxed-ux10duxedsel}{%
\subsection{Formátování čísel}\label{formuxe1tovuxe1nuxed-ux10duxedsel}}

Někdy potřebujeme vytisknout čísla v~``pěkném formátu''. To znamená, že musíme převést dané číslo na zformátovaný řetězec, který dané číslo prezentuje v~požadovaném tvaru. K~tomu slouží funkce \texttt{format()} ze základního balíku \textbf{base}. Funkce \texttt{format()} je \emph{generická} a umí formátovat mnoho různých objektů. Pro čísla má následující parametry:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{format}\NormalTok{(x, }\AttributeTok{trim =} \ConstantTok{FALSE}\NormalTok{, }\AttributeTok{digits =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{nsmall =}\NormalTok{ 0L,}
       \AttributeTok{justify =} \FunctionTok{c}\NormalTok{(}\StringTok{"left"}\NormalTok{, }\StringTok{"right"}\NormalTok{, }\StringTok{"centre"}\NormalTok{, }\StringTok{"none"}\NormalTok{),}
       \AttributeTok{width =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{na.encode =} \ConstantTok{TRUE}\NormalTok{, }\AttributeTok{scientific =} \ConstantTok{NA}\NormalTok{,}
       \AttributeTok{big.mark   =} \StringTok{""}\NormalTok{,   }\AttributeTok{big.interval =}\NormalTok{ 3L,}
       \AttributeTok{small.mark =} \StringTok{""}\NormalTok{, }\AttributeTok{small.interval =}\NormalTok{ 5L,}
       \AttributeTok{decimal.mark =} \FunctionTok{getOption}\NormalTok{(}\StringTok{"OutDec"}\NormalTok{),}
       \AttributeTok{zero.print =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{drop0trailing =} \ConstantTok{FALSE}\NormalTok{, ...)}
\end{Highlighting}
\end{Shaded}

kde \texttt{x} je numerický vektor. Další užitečné parametry jsou zejména \texttt{nsmall} (minimální počet desetinných míst), \texttt{big.mark} a \texttt{decimal.mark} (znak oddělující tisíce a desetinná místa), \texttt{scientific} (pokud je \texttt{TRUE}, pak vypisuje čísla ve vědecké notaci), \texttt{width} (minimimální počet znaků) a \texttt{justify} (zarovnání). Další parametry jsou popsané v~dokumentaci.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FloatTok{123456.3}
\FunctionTok{print}\NormalTok{(x)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 123456.3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(}\FunctionTok{format}\NormalTok{(x, }\AttributeTok{big.mark =} \StringTok{"."}\NormalTok{, }\AttributeTok{decimal.mark =} \StringTok{","}\NormalTok{, }\AttributeTok{nsmall =} \DecValTok{2}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "123.456,30"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(}\FunctionTok{format}\NormalTok{(x, }\AttributeTok{scientific =} \ConstantTok{TRUE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "1.234563e+05"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(}\FunctionTok{format}\NormalTok{(x, }\AttributeTok{width =} \DecValTok{10}\NormalTok{, }\AttributeTok{justify =} \StringTok{"left"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "  123456.3"
\end{verbatim}

\hypertarget{reguluxe1rnuxed-vuxfdrazy}{%
\section{Regulární výrazy}\label{reguluxe1rnuxed-vuxfdrazy}}

Jednoduché úpravy řetězců popsané výše a hledání, jaké je obvyklé v~programech typu Word nebo Excel nestačí, když řešíme nějakou složitější situaci. Řekněme, že potřebujeme v~textu najít každé telefonní číslo a převést je na nějaký standardní tvar. Každé telefonní číslo se však skládá z~jiných číslic a navíc mohou být tyto číslice i~různě oddělené: telefonní číslo \texttt{123456789} je totéž, co \texttt{123\ 456\ 789}, \texttt{+420\ 123\ 456\ 789} a \texttt{+420-123-456-789}. Podobné problémy nastávají i~při zjišťování data: stejné datum může být např.~zadané jako \texttt{1.6.2006}, \texttt{1.\ 6.\ 2006} i~\texttt{1.\ června\ 2006}. K~hledání a úpravám takto volně definovaných skupin znaků slouží regulární výrazy.

Regulární výraz je řetězec, který obsahuje vzor (\emph{pattern}) toho, jak vypadá hledaný kus textu. Je to tedy jakási abstraktní maska, která ukazuje, jaké vlastnosti musí kus textu splňovat, aby byl vybrán. Zkoumaný řetězec se pak prochází a hledají se ty jeho části, které splňují daný vzor.
Bohužel se regulární výrazy implementované v~různých programech od sebe mírně liší. Z~historických důvodů se dnes v~R používají tři různé typy regulárních výrazů: základní funkce v~R používají regulární výrazy standardu POSIX~1003.2 nebo (na požádání) regulární výrazy podle standardu jazyka Perl. Balík \textbf{stringr} používá regulární výrazy založené na ICU. Naštěstí se od sebe různé standardy liší jen v~různých nadstavbách. Zde se podíváme na základ, který je společný všem třem výše zmíněným formám regulárních výrazů. (Plné definice těchto standardů najdete v~dokumentaci funkcí: \texttt{help("regex",\ package\ =\ "base")} pro POSIX a \texttt{help("stringi-search-regex",\ package\ =\ "stringi")} pro ICU.)

Jak už bylo řečeno, regulární výraz je řetězec. Některé znaky v~něm se berou doslovně, jiné mají speciální význam, který může záviset na kontextu, ve kterém jsou použité. Prakticky používají regulární výrazy čtyři operace:

\begin{itemize}
\tightlist
\item
  spojování~-- znaky zapsané za sebou se spojí do jednoho výrazu; např.~\texttt{abcd} je spojení čtyř znaků, které fungují jako celek, tj.~jako řetězec ``abcd''
\item
  logické ``nebo'' označené symbolem \texttt{\textbar{}} vybírá jednu z~možností; např.~\texttt{ab\textbar{}cd} znamená řetězec ``ab'' nebo řetězec ``cd'', protože spojování má vyšší prioritu než ``nebo''
\item
  opakování~-- umožňuje říct, kolikrát se má nějaký řetězec v~textu vyskytovat; k~tomu poskytují regulární výrazy \emph{kvantifikátory}, viz dále; např.~\texttt{abc+} znamená řetězce \texttt{abc}, \texttt{abcc}, \texttt{abccc} atd.; opakuje se jen poslední znak, protože operace spojování i~``nebo'' mají nižší prioritu než kvantifikátory
\item
  seskupování~-- znaky zapsané do obyčejných závorek \texttt{(\ )} tvoří skupinu, tj.~jeden celek, který se může např.~opakovat, měnit priority vyhodnocování výrazů apod., protože seskupení má nejvyšší prioritu ze všech operací; skupiny mají i~speciální význam při vybírání částí regulárních výrazů, viz dále
\end{itemize}

Všechny znaky kromě \texttt{{[}\textbackslash{}\^{}\$.\textbar{}?*+()\{\}} se berou doslovně, tj.~např.~\texttt{a}~znamená písmeno~``a'', \texttt{1}~znamená číslici~``1'' atd. Regulární výraz \texttt{"jak"} tedy najde v~textu všechny výskyty slova ``jak'' všechně výskytů v~jiných slovech, např.~``jakkoli''; nenajde však ``Jak'', protože regulární výraz chápe malá a velká písmena jako různé znaky.

Znaky \texttt{{[}\textbackslash{}\^{}\$.\textbar{}?*+()\{\}} mají speciální význam. To znamená, že výraz \texttt{cože?} nenajde doslovně řetězec ``cože?'' (ve skutečnosti najde řetězec ``což'' nebo řetězec ``cože''). Stejně tak \texttt{Ano.} neznamená doslovně ``Ano.'', nýbrž jakýkoli řetězec, ve kterém za ``Ano'' následuje jeden znak (např.~``Ano!'').
Konkrétně tečka \texttt{.} označuje libovolný znak včetně mezer, tabelátorů apod. Výraz \texttt{ma.ka} najde slova jako ``matka'', ``maska'' nebo ``marka'', ale ne ``maka''.

Pokud chcete zadat přímo speciální znak, je třeba jej zabezpečit pomocí zpětného lomítka. Skutečná tečka je tedy \texttt{\textbackslash{}.}, hranatá závorka je \texttt{\textbackslash{}{[}} atd.
Bohužel je v~R zpětné lomítko samo aktivním znakem. To znamená, že je třeba jej zabezpečit dalším zpětným lomítkem. Místo \texttt{\textbackslash{}.} je tak třeba zadat \texttt{"\textbackslash{}\textbackslash{}."} apod. Nepříjemné je to v~případě, kdy potřebujete hledat doslovně zpětné lomítko. V~regulárním výrazu je musíte zabezpečit jiným zpětným lomítkem, takže dostanete \texttt{\textbackslash{}\textbackslash{}}. V~R však dále musíte každé zpětné lomítko zabezpečit dalším zpětným lomítkem, takže regulární výraz, který hledá zpětné lomítko musí být v~R zadaný jako čtyři zpětná lomítka: \texttt{\textbackslash{}\textbackslash{}\textbackslash{}\textbackslash{}}.

\hypertarget{rozsahy}{%
\subsection{Rozsahy}\label{rozsahy}}

Někdy chceme najít řetězec, který obsahuje jakýkoli znak z~určité množiny. K~tomu slouží rozsahy (\emph{character classes}). Nejjednodušší způsob, jak v~regulárním výrazu zadat rozsah, je použít operátor hranatá závorka.
Hranaté závorky určují výčet platných znaků. Tak např.~\texttt{{[}Aa{]}} najde všechny výskyty malého ``a'' a velkého ``A''. Takže výrazu \texttt{{[}Aa{]}dam} vyhoví jak ``Adam'', tak ``adam''.
V~případě číslic a ASCII znaků mohou hranaté závorky obsahovat i~rozsah zadaný pomocí pomlčky. Pro nalezení číslic~0 až~4 tedy není třeba psát \texttt{{[}01234{]}}, nýbrž stačí \texttt{{[}0-4{]}}. Pokud se má pomlčka chápat v~rozsahu doslovně, je třeba ji napsat jako první znak.
Hranaté závorky mohou obsahovat i~negaci, ke které slouží znak \texttt{\^{}} uvedený hned za otevírající hranatou závorkou. Výraz \texttt{{[}\^{}Aa{]}} splňují všechny znaky mimo malého ``a'' a velkého ``A''.

Pro některé často užívané výčty existují speciální symboly. Tabulka~\ref{tab:strings-old-char-classes} uvádí nejdůležitější z~nich. Kromě těchto rozsahů mohou regulární výrazy v~R obsahovat i~POSIXové rozsahy, které mají zvláštní tvar \texttt{{[}:jméno:{]}} a mohou se vyskytovat jen ve vnějším rozsahu, tj.~jako \texttt{{[}{[}:jméno:{]}{]}} nebo např.~\texttt{{[}a{[}:jméno:{]}b{]}} apod. Jejich seznam uvádí tabulka~\ref{tab:strings-posix-char-classes}. POSIXové rozsahy se od základních rozsahů liší v~tom, že respektují \emph{locale} počítače, takže mezi písmena počítají i~znaky národní abecedy.
Rozdíl mezi \texttt{\textbackslash{}w} a \texttt{{[}:alnum:{]}} tedy spočívá v~tom, že \texttt{{[}:alnum:{]}} obsahuje v~českém \emph{locale} i~písmena s~háčky a čárkami, zatímco \texttt{\textbackslash{}w} obsahuje jen písmena anglické abecedy (zahrnutá v~ASCII). Pokud tedy uvažujete písmena, doporučuji používat vždy POSIXové rozsahy.

\begin{longtable}[]{@{}lll@{}}
\caption{\label{tab:strings-old-char-classes} Přehled základních rozsahů používaných v~regulárních výrazech.}\tabularnewline
\toprule
symbol & význam & výčtem \\
\midrule
\endfirsthead
\toprule
symbol & význam & výčtem \\
\midrule
\endhead
\texttt{\textbackslash{}d} & číslice & \texttt{{[}0-9{]}} \\
\texttt{\textbackslash{}D} & není číslice & \texttt{{[}\^{}0-9{]}} \\
\texttt{\textbackslash{}w} & písmeno, číslice nebo podtržítko & \texttt{{[}a-zA-z0-9\_{]}} \\
\texttt{\textbackslash{}W} & cokoli, co není \texttt{\textbackslash{}w} & \texttt{{[}\^{}a-zA-z0-9\_{]}} \\
\texttt{\textbackslash{}s} & prázdný znak & \texttt{{[}\ \textbackslash{}t\textbackslash{}n\textbackslash{}r\textbackslash{}f{]}} \\
\texttt{\textbackslash{}S} & není prázdný znak & \texttt{{[}\^{}\ \textbackslash{}t\textbackslash{}n\textbackslash{}r\textbackslash{}f{]}} \\
\texttt{\textbackslash{}b} & hranice slova & \\
\texttt{\textbackslash{}B} & není hranice slova & \\
\texttt{\textbackslash{}h} & horizontální mezera & \\
\texttt{\textbackslash{}H} & není horizontální mezera & \\
\texttt{\textbackslash{}v} & vertikální mezera & \\
\texttt{\textbackslash{}V} & není vertikální mezera & \\
\bottomrule
\end{longtable}

\begin{longtable}[]{@{}
  >{\raggedright\arraybackslash}p{(\columnwidth - 2\tabcolsep) * \real{0.14}}
  >{\raggedright\arraybackslash}p{(\columnwidth - 2\tabcolsep) * \real{0.86}}@{}}
\caption{\label{tab:strings-posix-char-classes} Přehled POSIXových rozsahů používaných v~regulárních výrazech.}\tabularnewline
\toprule
rozsah & význam \\
\midrule
\endfirsthead
\toprule
rozsah & význam \\
\midrule
\endhead
\texttt{{[}:lower:{]}} & malá písmena v~\emph{locale} počítače \\
\texttt{{[}:upper:{]}} & velká písmena v~\emph{locale} počítače \\
\texttt{{[}:alpha:{]}} & malá i~velká písmena v~\emph{locale} počítače \\
\texttt{{[}:digit:{]}} & číslice, tj.~0, 1, \ldots, 9 \\
\texttt{{[}:alnum:{]}} & alfanumerické znaky, tj.~\texttt{{[}:alpha:{]}} a \texttt{{[}:digit:{]}} \\
\texttt{{[}:blank:{]}} & mezera a tabelátor \\
\texttt{{[}:cntrl:{]}} & řídící znaky \\
\texttt{{[}:punct:{]}} & \texttt{!}, \texttt{"}, \texttt{\#}, \texttt{\%}, \texttt{\&}, \texttt{\textquotesingle{}}, \texttt{(}, \texttt{)}, \texttt{*}, \texttt{+}, \texttt{,}, \texttt{-}, \texttt{.}, \texttt{/}, \texttt{:}, \texttt{;}, \texttt{\textless{}}, \texttt{\textgreater{}}, \texttt{?}, \texttt{@}, \texttt{{[}}, \texttt{\textbackslash{}}, \texttt{{]}}, \texttt{\^{}}, \texttt{\_}, `\texttt{,}\{\texttt{,} \\
\bottomrule
\end{longtable}

\hypertarget{kvantifikuxe1tory}{%
\subsection{Kvantifikátory}\label{kvantifikuxe1tory}}

Znaky \texttt{*+?\{} jsou kvantifikátory, které řídí počet opakování předchozího znaku, rozsahu nebo skupiny. Jejich význam shrnuje tabulka~\ref{tab:strings-quantif}.

\begin{longtable}[]{@{}ll@{}}
\caption{\label{tab:strings-quantif} Přehled POSIXových rozsahů používaných v~regulárních výrazech.}\tabularnewline
\toprule
znak & význam \\
\midrule
\endfirsthead
\toprule
znak & význam \\
\midrule
\endhead
\texttt{*} & libovolný počet opakování (tj.~vůbec, jednou nebo víckrát) \\
\texttt{+} & aspoň jeden výskyt (tj.~jednou nebo víckrát) \\
\texttt{?} & maximálně jeden výskyt (tj.~vůbec nebo jednou) \\
\texttt{\{5\}} & právě pětkrát \\
\texttt{\{3,5\}} & nejméně třikrát a nejvýše pětkrát \\
\texttt{\{3,\}} & nejméně třikrát \\
\texttt{\{,5\}} & maximálně pětkrát \\
\bottomrule
\end{longtable}

Podívejme se na příklady:

\begin{itemize}
\tightlist
\item
  \texttt{.*} odpovídá jakémukoli znaku, který je opakovaný libovolně krát, tj.~jakýkoli řetězec včetně \texttt{""}
\item
  \texttt{\textbackslash{}w+} odpovídá aspoň jednomu písmenu anglické abecedy
\item
  \texttt{{[}+-{]}?\textbackslash{}d+} odpovídá celému číslu (najde např.~``+12'', ``1'', ``-3'' apod.; z~``3.14'' najde ``3'' a ``14'')
\end{itemize}

Kvantifikátory jsou ``hladové''. To znamená, že najdou řetězec s~maximální délkou, která vyhovuje vzoru. To se nemusí vždy hodit. Např.~pokud chceme najít všechny přímé řeči, regulární výraz \texttt{".*"} nebude fungovat, protože najde celý výraz mezi první a poslední uvozovkou:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \StringTok{\textquotesingle{}"Už je to dobré," řekl Josef. "Pojdme si zaplavat."\textquotesingle{}}
\FunctionTok{str\_extract\_all}\NormalTok{(s1, }\StringTok{\textquotesingle{}".*"\textquotesingle{}}\NormalTok{)  }\CommentTok{\# jeden řetězec od první po poslední uvozovku}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "\"Už je to dobré,\" řekl Josef. \"Pojdme si zaplavat.\""
\end{verbatim}

Problém vyřeší ``líný'' kvantifikátor, který najde řetězec s~minimální délkou, který splňuje zadaný vzor. Z~kvantifikátoru uděláte líný tak, že za něj připojíte otazník. Např.~kvantifikátor pro nula až nekonečný počet výskytů \texttt{*} je hladový; jeho líná verze je \texttt{*?}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_extract\_all}\NormalTok{(s1, }\StringTok{\textquotesingle{}".*?"\textquotesingle{}}\NormalTok{)  }\CommentTok{\# vektor dvou řetězců, v každém je jedna přímá řeč}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "\"Už je to dobré,\""     "\"Pojdme si zaplavat.\""
\end{verbatim}

\hypertarget{zaux10duxe1tek-a-konec-ux159etux11bzce}{%
\subsection{Začátek a konec řetězce}\label{zaux10duxe1tek-a-konec-ux159etux11bzce}}

Normálně regulární výrazy najdou jakoukoli část řetězce. Někdy je však užitečné hledat jen za začátku nebo na konci řetězce. K~tomu slouží ``kotvy'' (\emph{anchors}).
Znak \texttt{\^{}} uvedený na začátku regulárního výrazu znamená začátek řetězce (nebo ve speciálním případě řádku, viz dále).
Znak \texttt{\$} uvedený na konci regulárního výrazu znamená konec řetězce (nebo ve speciálním případě řádku, viz dále).

Pokud tedy chceme najít jen řádky, které začínají písmenem ``A'', můžeme použít regulární výraz \texttt{\^{}A}. Pokud chceme najít řádky, které končí tečkou, můžeme použít regulární výraz \texttt{\textbackslash{}.\$} (v~R bude potřeba zpětné lomítko zdvojit a zadat \texttt{"\textbackslash{}\textbackslash{}.\$"}). Výraz \texttt{\^{}-+\$} splní pouze řádky, které obsahují pouze pomlčky.

\hypertarget{skupiny}{%
\subsection{Skupiny}\label{skupiny}}

Někdy je potřeba některé znaky seskupit. K~tomu slouží kulaté závorky.
Skupiny ovlivňují priority vyhodnocování regulárního výrazu. To je užitečné např.~při alternaci. Např.~regulárnímu výrazu \texttt{abc\textbar{}def} vyhoví řetězce ``abc'' a ``def''. Naproti tomu výrazu \texttt{ab(c\textbar{}d)ef} vyhoví řetězce ``abcef'' a ``abdef''. (Normálně má spojení prioritu před alternací.)
Skupiny ovlivňují priority i~při použití kvantifikátorů. Např.~výrazu \texttt{abc*} vyhoví řetězce ``ab'', ``abc'', ``abcc'' atd. Naproti tomu výrazu \texttt{(abc)*} vyhoví prázdný řetězec \texttt{""}, ``abc'', ``abcabc'' atd. (Normálně má kvantifikátor přednost před spojením.)

Skupiny navíc dávají regulárním výrazům ``paměť''. První skupině odpovídá \texttt{\textbackslash{}1}, druhé skupině \texttt{\textbackslash{}2} atd. (Pokud jsou do sebe skupiny vložené, pak se jejich čísla počítají podle pořadí levé závorky.) Tuto paměť je možné využít jak ve vyhledávacím řetězci, tak při náhradě regulárního výrazu, viz dále. Např.~k~nalezení pětiznakového palindromu (tj.~slova, které je stejné, ať ho čteme zleva nebo zprava, např.~kajak nebo madam) můžeme použít regulární výraz \texttt{(.)(.).\textbackslash{}2\textbackslash{}1}. V~něm musí být znak \texttt{\textbackslash{}1} stejný jako první znak palindromu (odpovídající první skupině s~tečkou) a \texttt{\textbackslash{}2} musí být znak stejný jako druhý znak palinromu (odpovídající druhé skupině s~tečkou). (Náš regulární výraz najde ovšem i~palindromy složené z~čísel apod. Pro hledání skutečných palindromů by bylo bezpečnější nahradit v~regulárním výrazu tečky např.~rozsahem \texttt{{[}{[}:alpha:{]}{]}}.)

\hypertarget{pux159uxedklady}{%
\subsection{Příklady}\label{pux159uxedklady}}

Podívejme se nyní na regulární výrazy pro dva případy zmíněné výše: pro nalezení telefonního čísla a datumu.
Regulární výraz, který pozná všechny výše uvedené formáty telefonního čísla, vypadá takto: \texttt{(\textbackslash{}+420)?{[}\textbackslash{}s-{]}*\textbackslash{}d\{3\}{[}\textbackslash{}s-{]}*\textbackslash{}d\{3\}{[}\textbackslash{}s-{]}*\textbackslash{}d\{3\}}. V~R však musejí být všechna zpětná lomítka zdvojena, takže regulární výraz musí být zapsán takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{r }\OtherTok{\textless{}{-}} \StringTok{"(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{+420)?[{-}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s]*}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{3\}[{-}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s]*}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{3\}[{-}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s]*}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{3\}"}
\NormalTok{cisla }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"Leoš: 777 666 555 444"}\NormalTok{,}
           \StringTok{"Lída: domů +420 734 123 456, práce 777{-}666{-}555"}\NormalTok{,}
           \StringTok{"Leona: nevím"}\NormalTok{)}
\FunctionTok{str\_extract\_all}\NormalTok{(cisla, r)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] " 777 666 555"
## 
## [[2]]
## [1] "+420 734 123 456" " 777-666-555"    
## 
## [[3]]
## character(0)
\end{verbatim}

Regulární výraz, který pozná všechny výše uvedené formáty data:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{r }\OtherTok{\textless{}{-}} \FunctionTok{str\_c}\NormalTok{(}\StringTok{"}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{1,2\}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{.}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s*(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{1,2\}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{.|leden|únor|březen|duben|červen|červenec|srpen|"}\NormalTok{,}
           \StringTok{"září|říjen|listopad|prosinec)}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s*}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{4\}"}\NormalTok{)}
\NormalTok{dat }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"1. 6. 2001"}\NormalTok{, }\StringTok{"1.1.2012"}\NormalTok{, }\StringTok{"1. červen 2016"}\NormalTok{, }\StringTok{"ahoj"}\NormalTok{)}
\FunctionTok{str\_detect}\NormalTok{(dat, r)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  TRUE  TRUE  TRUE FALSE
\end{verbatim}

\hypertarget{praktickuxe1-pruxe1ce-s-reguluxe1rnuxedmi-vuxfdrazy}{%
\subsection{Praktická práce s~regulárními výrazy}\label{praktickuxe1-pruxe1ce-s-reguluxe1rnuxedmi-vuxfdrazy}}

Regulární výrazy jsou velmi mocné, ale poněkud nepřehledné. Vždy byste si proto měli vyzkoušet, zda váš regulární výraz 1)~nachází to, co chcete, a~2)~nenachází to, co nechcete. Je proto velmi užitečné, abyste si připravili několik příkladů řetězců, které by výraz měl a které by neměl najít.

K~otestování regulárního výrazu pak můžete použít buď funkce popsané v~dalším oddílu, nebo uživatelsky přívětivé funkce \texttt{str\_view(string,\ pattern,\ match\ =\ NA)} a \texttt{str\_view\_all(string,\ pattern,\ match\ =\ NA)}, kde \texttt{string} je prohledávaný vektor řetězců, \texttt{pattern} je zkoušený regulární výraz a \texttt{match} je logická hodnota. Pokud je \texttt{TRUE}, zobrazí jen řetězce, které splňují daný regulární výraz, pokud \texttt{FALSE}, pak zobrazí jen řetězce, které daný regulární výraz nesplňují. Pokud necháte implicitiní hodnotu~\texttt{NA}, pak zobrazí všechny zadané řetězce. Funkce zobrazí v~RStudiu v~záložce \texttt{Viewer} zadané řetězce a barevně vyznačí části, které odpovídají zadanému regulárnímu výrazu. První funkce zobrazí pouze první výskyt, zatímco druhá funkce všechny výskyty.
Pohodlné testování regulárních výrazů umožňuje i~doplněk RStudia RegExplain. Protože není zatím součástí CRANu, nainstalujete jej takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{devtools}\SpecialCharTok{::}\FunctionTok{install\_github}\NormalTok{(}\StringTok{"gadenbuie/regexplain"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

I~když váš regulární výraz funguje, měli byste být opatrní a pamatovat na to, že funguje jen za předem určených předpokladů: náš výraz pro datum např.~najde jen datum zadané tak, jak je zvykem v~České republice, a~to ještě jen v~případě, že je zadán i~rok. Pokud byste chtěli obecnější řešení, začal by váš regulární výraz být složitější a složitější. Pak se často vyplatí výraz zjednodušit a hledaný řetězec hledat na dvakrát nebo na třikrát a nebo využít i~jiné nástroje než jen regulární výrazy.
Některé texty byste neměli pomocí regulárních výrazů procházet téměř nikdy. Sem patří např.~webové stránky, které je možné procházet mnohem elegantněji s~použitím syntaxe \emph{XPath} nebo \emph{CSS}.

Pamatujte také, že regulární výrazy obsahují mnohem více než to, co jste viděli v~tomto oddílu. Plný výčet detailů je na těchto (podle mého mínění velmi nepřehledných) stránkách \url{http://www.regular-expressions.info/reference.html}. Ve většině případů vám však bude obsah tohoto oddílu bohatě stačit.

\hypertarget{funkce-pro-pruxe1ci-s-reguluxe1rnuxedmi-vuxfdrazy}{%
\section{Funkce pro práci s~regulárními výrazy}\label{funkce-pro-pruxe1ci-s-reguluxe1rnuxedmi-vuxfdrazy}}

Nyní se podíváme na to, jak využít regulární výrazy pro práci s~řetězci v~R.
Většina funkcí pro práci s~regulárními výrazy definovaná v~balíku \textbf{stringr} má podobnou syntaxi: \texttt{str\_XXX(string,\ pattern,\ ...)}, kde \texttt{XXX} je část jména funkce, \texttt{string} je vektor zpracovávaných řetězců, \texttt{pattern} je použitý regulární výraz a \texttt{...} případné další parametry. Pokud některá funkce vrací jen první výskyt hledaného vzoru v~řetězci, pak většinou existuje i~podobná funkce s~koncovkou \texttt{\_all}, která vrací všechny výskytu zadaného vzoru.

\hypertarget{detekce-vzoru}{%
\subsection{Detekce vzoru}\label{detekce-vzoru}}

Nejjednodušším případem použití regulárních výrazů je nalezení řetězců, které odpovídají danému regulárnímu výrazu.
K~detekci, zda řetězec odpovídá zvolenému regulárnímu výrazu, slouží funkce \texttt{str\_detect(string,\ pattern,\ negate\ =\ FALSE)}, kde \texttt{string} je prohledávaný vektor řetězců a \texttt{pattern} je hledaný vzor. Funkce vrací logický vektor stejné délky jako \texttt{string} s~hodnotou \texttt{TRUE}, pokud byl vzor nalezen, a~hodnotou \texttt{FALSE} v~opačném případě. Nastavení parametru \texttt{negate} na \texttt{TRUE} výsledek obrací: nyní funkce vrací \texttt{TRUE}, pokud řetězec daný vzor neobsahuje. Řekněme, že chceme zjistit, které řetězce ve vektoru \texttt{s1} obsahují slova o~pěti písmenech, kde první dvě jsou ``ma'' a poslední dvě ``ka'' (další příklady najdete výše):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"matka"}\NormalTok{, }\StringTok{"mačka"}\NormalTok{, }\StringTok{"mačká"}\NormalTok{, }\StringTok{"maska"}\NormalTok{, }\StringTok{"Matka"}\NormalTok{, }\StringTok{"marka!"}\NormalTok{, }\StringTok{"ma ka"}\NormalTok{)}
\FunctionTok{str\_detect}\NormalTok{(s1, }\StringTok{"ma.ka"}\NormalTok{)  }\CommentTok{\# TRUE, pokud obsahuje vzor}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  TRUE  TRUE FALSE  TRUE FALSE  TRUE  TRUE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_detect}\NormalTok{(s1, }\StringTok{"ma.ka"}\NormalTok{, }\AttributeTok{negate =} \ConstantTok{TRUE}\NormalTok{)  }\CommentTok{\# TRUE, pokud neobsahuje vzor}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] FALSE FALSE  TRUE FALSE  TRUE FALSE FALSE
\end{verbatim}

Funkce \texttt{str\_which(string,\ pattern,\ negate\ =\ FALSE)} je podobná a má i stejné parametry. Místo logických hodnot však vrací celočíselný vektor pozic prvků vektoru \texttt{string}, které splňují zadaný regulární výraz:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_which}\NormalTok{(s1, }\StringTok{"ma.ka"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 2 4 6 7
\end{verbatim}

Často potřebujeme řetězce, které odpovídají regulárnímu výrazu vybrat. To by bylo možné provést pomocí subsetování:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1[}\FunctionTok{str\_detect}\NormalTok{(s1, }\StringTok{"ma.ka"}\NormalTok{)]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "matka"  "mačka"  "maska"  "marka!" "ma ka"
\end{verbatim}

Balík \textbf{stringr} však k~tomuto účelu nabízí komfortnější funkci \texttt{str\_subset(string,\ pattern,\ negate\ =\ FALSE)}, která vrací ty prvky vektoru~\texttt{s}, které obsahují vzor~\texttt{p} (parametry funkce mají stejný význam jako u \texttt{str\_detect()}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_subset}\NormalTok{(s1, }\StringTok{"ma.ka"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "matka"  "mačka"  "maska"  "marka!" "ma ka"
\end{verbatim}

Podívejme se na praktičtější příklad. Řekněme, že chceme vybrat ty řetězce z~vektoru \texttt{cisla}, které obsahují telefonní čísla:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{r }\OtherTok{\textless{}{-}} \StringTok{"(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{+420)?[{-}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s]*}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{3\}[{-}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s]*}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{3\}[{-}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s]*}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{3\}"}
\NormalTok{cisla }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"Leoš: 777 666 555 444"}\NormalTok{,}
           \StringTok{"Lída: domů +420 734 123 456, práce 777{-}666{-}555"}\NormalTok{,}
           \StringTok{"Leona: nevím"}\NormalTok{)}
\FunctionTok{str\_subset}\NormalTok{(cisla, r)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Leoš: 777 666 555 444"                         
## [2] "Lída: domů +420 734 123 456, práce 777-666-555"
\end{verbatim}

Mohl by nás zajímat i~počet výskytů regulárního výrazu v~řetězci. K~tomu slouží funkce \texttt{str\_count(string,\ pattern)}, která spočítá počet výskytů regulárního výrazu~\texttt{pattern} v~řetězci~\texttt{string}. Pracuje vektorově přes zadaný vektor řetězců~\texttt{string} i~přes regulární výraz~\texttt{pattern}. Implicitní hodnota~\texttt{pattern} je prázdný řetězec \texttt{""}. V~tomto případě vrací funkce \texttt{str\_count()} počet znaků v~řetězci (počítaných podle aktuálního \emph{locale}). Podívejme se na několik příkladů:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ovoce }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"jablko"}\NormalTok{, }\StringTok{"ananas"}\NormalTok{, }\StringTok{"hruška"}\NormalTok{, }\StringTok{"rybíz"}\NormalTok{)}
\FunctionTok{str\_count}\NormalTok{(ovoce, }\StringTok{"a"}\NormalTok{)  }\CommentTok{\# počet výskytů "a" v každém slově}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 3 1 0
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# počet "a" v jablku, "a" v ananasu, "b" v hrušce a "r" v rybízu}
\FunctionTok{str\_count}\NormalTok{(ovoce, }\FunctionTok{c}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"r"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 1 3 0 1
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_count}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"Ahoj"}\NormalTok{, }\StringTok{"lidičky!"}\NormalTok{))  }\CommentTok{\# počet znaků v každém řetězci}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 4 8
\end{verbatim}

\hypertarget{zuxedskuxe1nuxed-ux10duxe1stuxed-ux159etux11bzcux16f-kteruxe9-splnujuxed-vzor}{%
\subsection{Získání částí řetězců, které splnují vzor}\label{zuxedskuxe1nuxed-ux10duxe1stuxed-ux159etux11bzcux16f-kteruxe9-splnujuxed-vzor}}

Většinou nám nestačí najít výskyt řetězce, který odpovídá regulárnímu výrazu, ale chceme tento řetězec získat. K~tomu slouží funkce \texttt{str\_extract(string,\ pattern)}, která získá z~každého řetězce ve vektoru~\texttt{string} tu jeho část, která odpovídá prvnímu výskytu vzoru~\texttt{pattern}. Funkce vrací vektor stejné délky jako~\texttt{string}; pokud není vzor nalezen, vrací~\texttt{NA}.

Řekněme, že chceme např.~vybrat z~tweetů jednotlivé hashtagy (zjednodušíme si život a budeme předpokládat, že hashtag začíná křížkem a tvoří ho písmena a čísla a končí s~prvním výskytem ne-alfanumerického znaku jako je mezera, tečka, čárka apod.):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{r }\OtherTok{\textless{}{-}} \StringTok{"\#[[:alpha:]]+"}  \CommentTok{\# hashtag následovaný jedním nebo více písmeny}
\NormalTok{tweet }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"\#Brno je prostě nejlepší a \#MU je nejlepší v Brně."}\NormalTok{,}
           \StringTok{"Někdy je možné najít zajímavé podcasty na \#LSE."}\NormalTok{,}
           \StringTok{"Stupnování \textquotesingle{}divnosti\textquotesingle{}: divný, divnější, \#ParisHilton."}\NormalTok{,}
           \StringTok{"Docela prázdný tweet."}\NormalTok{)}
\FunctionTok{str\_extract}\NormalTok{(tweet, r)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "#Brno"        "#LSE"         "#ParisHilton" NA
\end{verbatim}

Funkce \texttt{str\_extract()} vrací pouze první výskyt výrazu v~každém řetězci. Pokud chceme získat všechny výskyty, musíme použít funkci \texttt{str\_extract\_all(string,\ pattern,\ simplify\ =\ FALSE)}. Implicitně funkce vrací seznam, jehož prvky odpovídají prvkům vektoru~\texttt{string}; nenalezené výskyty pak indikuje prázdný vektor řetězců (\texttt{character(0)}). Funkce však umí zjednodušit výsledek na matici. K~tomu slouží parametr \texttt{simplify} nastavený na hodnotu \texttt{TRUE}. V~tomto případě odpovídají řádky výsledné matice prvkům vektoru~\texttt{string}; nenalezené výskyty jsou pak označené jako prázdné řetězce \texttt{""}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_extract\_all}\NormalTok{(tweet, r)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "#Brno" "#MU"  
## 
## [[2]]
## [1] "#LSE"
## 
## [[3]]
## [1] "#ParisHilton"
## 
## [[4]]
## character(0)
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_extract\_all}\NormalTok{(tweet, r, }\AttributeTok{simplify =} \ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1]           [,2] 
## [1,] "#Brno"        "#MU"
## [2,] "#LSE"         ""   
## [3,] "#ParisHilton" ""   
## [4,] ""             ""
\end{verbatim}

Někdy nechceme získat celý vzor, nýbrž pouze jeho části. K~tomu slouží funkce \texttt{str\_match(string,\ pattern)} a \texttt{str\_match\_all(string,\ pattern)}, kde \texttt{string} je vektor prohledávaných řetězců a \texttt{pattern} regulární výraz. K~rozdělení regulárního výrazu do částí se používají skupiny.
Funkce \texttt{str\_match()} hledá první výskyt regulárního výrazu~\texttt{pattern} v~řetězci a vrací matici, jejíž řádky odpovídají prvkům vektoru~\texttt{string}. První sloupec je celý regulární výraz, druhý sloupec první skupina v~regulárním výrazu, třetí sloupec druhá skupina atd. (Pokud jsou skupiny zanořené jedna do druhé, pak se jejich pořadí počítá podle pořadí levé závorky.) Nenalezené prvky mají hodnotu~\texttt{NA}.

Pokud např.~chceme získat jméno hashtagu bez křížku, můžeme vzít druhý sloupec matice, kterou v našem případě vrátí funkce \texttt{str\_match()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{r }\OtherTok{\textless{}{-}} \StringTok{"\#([[:alpha:]]+)"}  \CommentTok{\# totéž, co výše, ale všechna písmena tvoří skupinu}
\FunctionTok{str\_match}\NormalTok{(tweet, r)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1]           [,2]         
## [1,] "#Brno"        "Brno"       
## [2,] "#LSE"         "LSE"        
## [3,] "#ParisHilton" "ParisHilton"
## [4,] NA             NA
\end{verbatim}

Poznámka: Vždy stojí za zvážení, zda provést nějakou operaci naráz pomocí složitého regulárního výrazu, nebo ji rozdělit do několika kroků. Extrakci hashtagů z~minulého příkladu můžeme snadno provést ve dvou jednodušších krocích: nejdříve extrahovat celý hashtag, a~pak z~něj odstranit křížek:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_extract}\NormalTok{(tweet, r) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{str\_remove}\NormalTok{(}\StringTok{"\#"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Brno"        "LSE"         "ParisHilton" NA
\end{verbatim}

Funkce \texttt{str\_match\_all()} vrací všechny výskyty regulárního výrazu. Jejím výsledkem je seznam matic. Řádky těchto matic odpovídají jednotlivým nálezům. Sloupce mají význam jako výše. Pokud není regulární výraz v~daném řádku nalezen, je výsledkem prázdná matice.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_match\_all}\NormalTok{(tweet, r)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
##      [,1]    [,2]  
## [1,] "#Brno" "Brno"
## [2,] "#MU"   "MU"  
## 
## [[2]]
##      [,1]   [,2] 
## [1,] "#LSE" "LSE"
## 
## [[3]]
##      [,1]           [,2]         
## [1,] "#ParisHilton" "ParisHilton"
## 
## [[4]]
##      [,1] [,2]
\end{verbatim}

Podívejme se opět na poněkud komplexnější příklad. Vektor \texttt{cisla} obsahuje řetězce, které obsahují telefonní čísla. Pro každého člověka chceme získat jeho první telefonní číslo a převést je do standardního tvaru (řekněme, že standardní tvar vynechává předčíslí země a trojice čísel odděluje pomlčkou). Postup může být následující: nejdříve získáme jednotlivé výskyty regulárního výrazu pomocí funkce \texttt{str\_match()}. Z~výsledku si vezmeme pouze skupiny, které odpovídají trojicím čísel (v~našem případě třetí, čtvrtý a pátý sloupec výsledku). Nakonec spojíme jednotlivá trojčíslí do jednoho řetězce pomocí funkce \texttt{str\_c()}; abychom jí zabránili spojit všechna trojčíslí pro všechny lidi dohromady, aplikujeme funkci \texttt{str\_c()} na jednotlivé řádky matice pomocí funkce \texttt{map\_chr()} z~balíku \textbf{purrr}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{r }\OtherTok{\textless{}{-}} \StringTok{"(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{+420)?[{-}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s]*(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{3\})[{-}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s]*(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{3\})[{-}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s]*(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{3\})"}
\NormalTok{cisla }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"Leoš: 777 666 555 444"}\NormalTok{,}
           \StringTok{"Lída: domů +420 734 123 456, práce 777{-}666{-}555"}\NormalTok{,}
           \StringTok{"Leona: nevím"}\NormalTok{)}
\NormalTok{cisla2 }\OtherTok{\textless{}{-}} \FunctionTok{str\_match}\NormalTok{(cisla, r)[, }\DecValTok{3}\SpecialCharTok{:}\DecValTok{5}\NormalTok{]}
\NormalTok{purrr}\SpecialCharTok{::}\FunctionTok{map\_chr}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\FunctionTok{nrow}\NormalTok{(cisla2), }\SpecialCharTok{\textasciitilde{}} \FunctionTok{str\_c}\NormalTok{(cisla2[., ], }\AttributeTok{collapse =} \StringTok{"{-}"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "777-666-555" "734-123-456" NA
\end{verbatim}

\hypertarget{indexy-ux159etux11bzcux16f-splnujuxedcuxedch-vzor}{%
\subsection{Indexy řetězců splnujících vzor}\label{indexy-ux159etux11bzcux16f-splnujuxedcuxedch-vzor}}

Někdy se hodí najít indexy, kde začíná a končí vzor v~daném řetězci. K~tomu slouží funkce \texttt{str\_locate()} a \texttt{str\_locate\_all}. Funkce \texttt{str\_locate(string,\ pattern)} najde indexy prvního výskytu regulárního výrazu \texttt{pattern} v~řetězci~\texttt{string}. Výsledkem je matice, jejíž řádky odpovídají prvkům vektoru~\texttt{string}. První sloupec je index začátku prvního výskytu vzoru, druhý sloupec je index konce prvního výskytu vzoru. Pokud není vzor v~řetězci nalezen, vrátí \texttt{NA}. Nalezené indexy výskytu řetězce je možné následně použít k~extrakci daného řetězce pomocí funkce \texttt{str\_sub()}. To je však ekvivalentní k~použití funkce \texttt{str\_extract()}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{r }\OtherTok{\textless{}{-}} \StringTok{"\#[[:alpha:]]+"}  \CommentTok{\# hashtag následovaný jedním nebo více písmeny}
\NormalTok{tweet }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"\#Brno je prostě nejlepší a \#MU je nejlepší v Brně."}\NormalTok{,}
           \StringTok{"Někdy je možné najít zajímavé podcasty na \#LSE."}\NormalTok{,}
           \StringTok{"Stupnování \textquotesingle{}divnosti\textquotesingle{}: divný, divnější, \#ParisHilton."}\NormalTok{,}
           \StringTok{"Docela prázdný tweet."}\NormalTok{)}
\FunctionTok{str\_locate}\NormalTok{(tweet, r)  }\CommentTok{\# vrací matici indexů prvních výskytů klíčových slov v tweetu}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      start end
## [1,]     1   5
## [2,]    43  46
## [3,]    41  52
## [4,]    NA  NA
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_sub}\NormalTok{(tweet, }\FunctionTok{str\_locate}\NormalTok{(tweet, r))  }\CommentTok{\# vyřízne tato klíčová slova}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "#Brno"        "#LSE"         "#ParisHilton" NA
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_extract}\NormalTok{(tweet, r)  }\CommentTok{\# totéž}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "#Brno"        "#LSE"         "#ParisHilton" NA
\end{verbatim}

K~nalezení všech výskytů vzoru ve vektoru řetězců~\texttt{string} slouží funkce \texttt{str\_locate\_all(string,\ pattern)}, která vrací seznam matic indexů. Prvky seznamu odpovídají prvkům vektoru~\texttt{string}. Řádky každé matice odpovídají jednotlivým výskytům vzoru v~jednom prvku vektoru~\texttt{string}. První sloupec matice je index začátku výskytu, druhý sloupec je index konce výskytu. Pokud není vzor nalezen, vrací prázdnou matici:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_locate\_all}\NormalTok{(tweet, r)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
##      start end
## [1,]     1   5
## [2,]    28  30
## 
## [[2]]
##      start end
## [1,]    43  46
## 
## [[3]]
##      start end
## [1,]    41  52
## 
## [[4]]
##      start end
\end{verbatim}

Funkce \texttt{invert\_match(loc)} invertuje matici indexů vrácenou funkcí \texttt{str\_locate\_all()}, takže obsahuje indexy částí řetězce, které \emph{neodpovídají} vzoru. Detaily najdete v~dokumentaci.

\hypertarget{nahrazenuxed-vzoru}{%
\subsection{Nahrazení vzoru}\label{nahrazenuxed-vzoru}}

Regulární výrazy umožňují i~nahrazení částí řetězců, které odpovídají danému regulárnímu výrazu. K~tomu slouží funkce \texttt{str\_replace()} a \texttt{str\_replace\_all()}. Funkce \texttt{str\_replace(string,\ pattern,\ replacement)} nahradí ve vektoru řetězců~\texttt{string} první výskyt vzoru~\texttt{pattern} řetězcem~\texttt{replacement}. Funkce \texttt{str\_replace\_all()} má stejnou syntaxi, ale nahradí všechny výskyty vzoru ve vektoru~\texttt{string}.

Začněme nejjednodušším případem. Řekněme, že chceme v~každém tweetu skrýt hashtagy: nahradit je řetězcem ```XXX'' nebo je úplně vymazat. To můžeme udělat např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{r }\OtherTok{\textless{}{-}} \StringTok{"\#[[:alpha:]]+"}
\FunctionTok{str\_replace\_all}\NormalTok{(tweet, r, }\StringTok{"\#XXX"}\NormalTok{)  }\CommentTok{\# náhrada hashtagu pomocí \#XXX}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "#XXX je prostě nejlepší a #XXX je nejlepší v Brně."
## [2] "Někdy je možné najít zajímavé podcasty na #XXX."   
## [3] "Stupnování 'divnosti': divný, divnější, #XXX."     
## [4] "Docela prázdný tweet."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_replace\_all}\NormalTok{(tweet, r, }\StringTok{""}\NormalTok{)  }\CommentTok{\# vymazání hashtagu}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] " je prostě nejlepší a  je nejlepší v Brně." 
## [2] "Někdy je možné najít zajímavé podcasty na ."
## [3] "Stupnování 'divnosti': divný, divnější, ."  
## [4] "Docela prázdný tweet."
\end{verbatim}

Pokud chceme nějaký text odstranit, můžeme jej nahradit prázdným řetězcem (jak ukazuje příklad výše), nebo použít užitečnou zkratku, kterou nabízí funkce \texttt{str\_remove(string,\ pattern)} a \texttt{str\_remove\_all(string,\ pattern)}. Ta první odstraní první výskyt regulárního výrazu \texttt{pattern} z~řetězce \texttt{string}, druhá všechny výskyty. Vymazat hashtag můžeme tedy i~takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_remove\_all}\NormalTok{(tweet, r)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] " je prostě nejlepší a  je nejlepší v Brně." 
## [2] "Někdy je možné najít zajímavé podcasty na ."
## [3] "Stupnování 'divnosti': divný, divnější, ."  
## [4] "Docela prázdný tweet."
\end{verbatim}

Funkce \texttt{str\_replace\_all()} dokáže nahradit více vzorů naráz. K~tomu stačí nahradit vzor~\texttt{pattern} a nahrazující řetězec~\texttt{replacement} pojmenovaným vektorem řetězců: jména prvků vektorů určují, co se nahrazuje, hodnoty určují, čím se nahrazuje. Řekněme, že chceme nahradit slova ``jeden'', ``dva'' a ``tři'' odpovídajícími číslicemi:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ovoce }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"jeden banán"}\NormalTok{, }\StringTok{"dva pomeranče"}\NormalTok{, }\StringTok{"tři mandarinky"}\NormalTok{)}
\FunctionTok{str\_replace\_all}\NormalTok{(ovoce,}
                \FunctionTok{c}\NormalTok{(}\StringTok{"jeden"} \OtherTok{=} \StringTok{"1"}\NormalTok{, }\StringTok{"dva"} \OtherTok{=} \StringTok{"2"}\NormalTok{, }\StringTok{"tři"} \OtherTok{=} \StringTok{"3"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "1 banán"      "2 pomeranče"  "3 mandarinky"
\end{verbatim}

Regulární výrazy však dokáží víc než jen nahradit kus řetězce jiným fixním řetězcem (např.~``XXX''): dokáží náhradu zkonstruovat přímo z~nahrazovaného textu. K~tomu opět slouží skupiny.
Funkce \texttt{str\_replace()} i \texttt{str\_replace\_all()} si zapamatují obsah skupin obsažených v~regulárním výrazu a mohou jej použít v~nahrazujícím řetězci~\texttt{r}. Obsah první skupiny je \texttt{\textbackslash{}1}, druhé skupiny \texttt{\textbackslash{}2} atd. (v~R je ovšem třeba zpětné lomítko zdvojit). Řekněme, že chceme hashtagy v~tweetech upravit tak, že hashtag bude nejdříve uveden bez křížku, a~pak v~závorce s~křížkem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{r }\OtherTok{\textless{}{-}} \StringTok{"\#([[:alpha:]]+)"}
\FunctionTok{str\_replace\_all}\NormalTok{(tweet, r, }\StringTok{"}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{1 (\#}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{1)"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "Brno (#Brno) je prostě nejlepší a MU (#MU) je nejlepší v Brně."     
## [2] "Někdy je možné najít zajímavé podcasty na LSE (#LSE)."              
## [3] "Stupnování 'divnosti': divný, divnější, ParisHilton (#ParisHilton)."
## [4] "Docela prázdný tweet."
\end{verbatim}

Paměť v~regulárních výrazech se dá použít na celou řadu praktických úprav řetězců. Řekněme například, že máme vektor datumů v~anglosaském formátu ``MM-DD-YYYY'', a~chceme je převést do českého formátu ``DD. MM. YYYY''. Bez regulárních výrazů to může být pracná záležitost. S~použitím regulárních výrazů je to hračka:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{datumy }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"born: 06{-}01{-}1921"}\NormalTok{, }\StringTok{"died: 02{-}01{-}2017"}\NormalTok{, }\StringTok{"no information at all"}\NormalTok{)}
\FunctionTok{str\_replace\_all}\NormalTok{(datumy, }\StringTok{"(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{2\}){-}(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{2\}){-}(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{4\})"}\NormalTok{, }\StringTok{"}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{2. }\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{1. }\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{3"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "born: 01. 06. 1921"    "died: 01. 02. 2017"    "no information at all"
\end{verbatim}

\hypertarget{rozdux11blenuxed-ux159etux11bzcux16f-podle-vzoru}{%
\subsection{Rozdělení řetězců podle vzoru}\label{rozdux11blenuxed-ux159etux11bzcux16f-podle-vzoru}}

Často je potřeba rozdělit řetězec do několika částí oddělených nějakým vzorem. K~tomu slouží funkce \texttt{str\_split(string,\ pattern,\ n\ =\ Inf,\ simplify\ =\ FALSE)} a \texttt{str\_split\_fixed(string,\ pattern,\ n)}, které rozdělí řetězec~\texttt{string} v~bodech, kde je nalezen vzor~\texttt{pattern}. Celé číslo~\texttt{n} určuje, na kolik částí je řetězec rozdělen. Funkce \texttt{str\_split()} nepotřebuje mít \texttt{n} zadané (implicitně rozdělí řetězec do tolika částí, do kolika je potřeba). Funkce vrací seznam, jehož každý prvek odpovídá jednomu prvku vektoru~\texttt{string}. Funkce \texttt{str\_split\_fixed()} musí mít zadaný počet~\texttt{n} a vrací matici, jejíž řádky odpovídají prvkům vektoru~\texttt{string} a sloupce jednotlivým nálezům (přebytečné sloupce jsou naplněné prázdným řetězcem~\texttt{""}). Pokud je počet~\texttt{n} nedostatečný, je nerozdělený zbytek řetězce vložen do posledního zadaného sloupce. Pokud však funkci \texttt{str\_split()} nastavíme parameter \texttt{simplify} na \texttt{TRUE}, pak také zjednoduší svůj výsledek do matice.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ovoce }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"jablka a hrušky a hrozny"}\NormalTok{, }\StringTok{"pomeranče a fíky a datle a pomela"}\NormalTok{)}
\FunctionTok{str\_split}\NormalTok{(ovoce, }\StringTok{" a "}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "jablka" "hrušky" "hrozny"
## 
## [[2]]
## [1] "pomeranče" "fíky"      "datle"     "pomela"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_split}\NormalTok{(ovoce, }\StringTok{" a "}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "jablka" "hrušky" "hrozny"
## 
## [[2]]
## [1] "pomeranče"      "fíky"           "datle a pomela"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_split\_fixed}\NormalTok{(ovoce, }\StringTok{" a "}\NormalTok{, }\DecValTok{4}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1]        [,2]     [,3]     [,4]    
## [1,] "jablka"    "hrušky" "hrozny" ""      
## [2,] "pomeranče" "fíky"   "datle"  "pomela"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_split\_fixed}\NormalTok{(ovoce, }\StringTok{" a "}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1]        [,2]     [,3]            
## [1,] "jablka"    "hrušky" "hrozny"        
## [2,] "pomeranče" "fíky"   "datle a pomela"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_split}\NormalTok{(ovoce, }\StringTok{" a "}\NormalTok{, }\AttributeTok{simplify =} \ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1]        [,2]     [,3]     [,4]    
## [1,] "jablka"    "hrušky" "hrozny" ""      
## [2,] "pomeranče" "fíky"   "datle"  "pomela"
\end{verbatim}

Řekněme, že potřebujeme rozdělit řetězce, které obsahují pouze dobře formátované datum v~české konvenci na den, měsíc a rok. To můžeme udělat např.~takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{datum }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"1.6.2001"}\NormalTok{, }\StringTok{"1. 2. 2003"}\NormalTok{, }\StringTok{"blábol"}\NormalTok{)}
\FunctionTok{str\_split\_fixed}\NormalTok{(datum, }\StringTok{"}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{.}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s*"}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1]     [,2] [,3]  
## [1,] "1"      "6"  "2001"
## [2,] "1"      "2"  "2003"
## [3,] "blábol" ""   ""
\end{verbatim}

Pokud řetězce s~daty nejsou formátované dobře, ale mohou být v~jednom z~formátů ``DD.MM.YYYY'', ``DD. MM. YYYY'' nebo ``DD-MM-YYYY'', pak stačí jen zobecnit regulární výraz, který jednotlivé složky data odděluje:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{datum }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"10{-}5{-}1999"}\NormalTok{, }\StringTok{"1.6.2001"}\NormalTok{, }\StringTok{"1. 12. 2003"}\NormalTok{, }\StringTok{"blábol"}\NormalTok{)}
\FunctionTok{str\_split\_fixed}\NormalTok{(datum, }\StringTok{"(}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{.}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{s*|{-})"}\NormalTok{, }\DecValTok{3}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##      [,1]     [,2] [,3]  
## [1,] "10"     "5"  "1999"
## [2,] "1"      "6"  "2001"
## [3,] "1"      "12" "2003"
## [4,] "blábol" ""   ""
\end{verbatim}

(Pro práci s~volně formátovanými daty má mnoho užitečných funkcí balík \textbf{lubridate}, viz~oddíl~\ref{sec-datetime}.)

Někdy chceme s~řetězci pracovat po slovech. K~tomu slouží funkce \texttt{word()}, která rozdělí řetězec na slova a vrátí slova se zadanými indexy. Použití je

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{word}\NormalTok{(string, }\AttributeTok{start =}\NormalTok{ 1L, }\AttributeTok{end =}\NormalTok{ start, }\AttributeTok{sep =} \FunctionTok{fixed}\NormalTok{(}\StringTok{" "}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

kde \texttt{string} je vektor rozdělovaných řetězců, \texttt{start} je index prvního vraceného slova, \texttt{end} je index posledního vraceného slova a \texttt{sep} je regulární výraz, který odděluje slova (implicitně je to jedna mezera). Indexy mohou být i~záporné~-- pak se počítají odzadu, tj.~\texttt{-1} je poslední slovo. Všechny parametry se recyklují.
Na příklady se podívejte do dokumentace.

\hypertarget{modifikace-chovuxe1nuxed-reguluxe1rnuxedch-vuxfdrazux16f}{%
\section{Modifikace chování regulárních výrazů}\label{modifikace-chovuxe1nuxed-reguluxe1rnuxedch-vuxfdrazux16f}}

Chování regulárních výrazů je možné ve funkcích z~balíku \textbf{stringr} modifikovat pomocí čtyř funkcí: \texttt{regex()}, \texttt{fixed()}, \texttt{coll()} a \texttt{boundary()}. Nejdůležitější z~nich je funkce \texttt{regex()}. Pokaždé, když zadáte regulární výraz, funkce z~balíku \textbf{stringr} na něj tiše uplatní funkci \texttt{regex()}, takže dva následující výrazy jsou zcela ekvivalentní:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s1 }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\StringTok{"máma"}\NormalTok{, }\StringTok{"Máma"}\NormalTok{, }\StringTok{"MÁMA"}\NormalTok{)}
\FunctionTok{str\_detect}\NormalTok{(s1, }\StringTok{"(.)á}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{1a"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  TRUE FALSE FALSE
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_detect}\NormalTok{(s1, }\FunctionTok{regex}\NormalTok{(}\StringTok{"(.)á}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{1a"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1]  TRUE FALSE FALSE
\end{verbatim}

Funkce \texttt{regex()} umožňuje poněkud modifikovat chování regulárního výrazu. K~tomu jí slouží čtyři parametry. Parametr \texttt{ignore\_case} umožňuje vypnout rozdíl mezi malými a velkými písmeny (\emph{case sensitivity}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_detect}\NormalTok{(s1, }\FunctionTok{regex}\NormalTok{(}\StringTok{"(.)á}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{1a"}\NormalTok{, }\AttributeTok{ignore\_case =} \ConstantTok{TRUE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE TRUE TRUE
\end{verbatim}

Normálně v~regulárních výrazech v~balíku \textbf{stringr} znamenají znaky \texttt{\^{}} a \texttt{\$} začátek a konec řetězce. Pokud mají znamenat začátek a konec řádku (což je obvyklejší), je třeba použít parametr \texttt{multiline}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s2 }\OtherTok{\textless{}{-}} \StringTok{"1. nakoupíš 7 vajec.}\SpecialCharTok{\textbackslash{}n}\StringTok{2. umyješ podlahu}\SpecialCharTok{\textbackslash{}n}\StringTok{3. nakrmíš králík"}
\FunctionTok{cat}\NormalTok{(s2)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 1. nakoupíš 7 vajec.
## 2. umyješ podlahu
## 3. nakrmíš králík
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_extract\_all}\NormalTok{(s2, }\StringTok{"\^{}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d+}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{."}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "1."
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_extract\_all}\NormalTok{(s2, }\FunctionTok{regex}\NormalTok{(}\StringTok{"\^{}}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d+}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{."}\NormalTok{, }\AttributeTok{multiline =} \ConstantTok{TRUE}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "1." "2." "3."
\end{verbatim}

Zbývající dva parametry jsou méně důležité: parametr \texttt{dotall} způsobí, že \texttt{.} zahrne všechny znaky, včetně konce řádku~\texttt{\textbackslash{}n}. Parametr \texttt{comments} umožňuje přidávat do regulárního výrazu komentáře.

Alternativou funkce \texttt{regex()} je funkce \texttt{fixed()}. Ta zajistí, že se výraz bere doslovně. Řekněme, že chceme spočítat počet souvětí v~řetězci a že počet souvětí aproximujeme počtem teček (naše souvětí vždy končí tečkou, ne vykřičníkem nebo otazníkem, a~text neobsahuje žádné zkratky, pořadová čísla ani tečky nevyužívá nijak jinak než na konci vět). Abychom našli všechny výskyty tečky v~řetězci, můžeme ji buď zbavit speciálního významu pomocí zpětného lomítka, nebo použít funkci \texttt{fixed()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s3 }\OtherTok{\textless{}{-}} \StringTok{"Máma má máso. Ema má mísu. Ó my se máme."}
\FunctionTok{str\_count}\NormalTok{(s3, }\StringTok{"}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{."}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_count}\NormalTok{(s3, }\FunctionTok{fixed}\NormalTok{(}\StringTok{"."}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] 3
\end{verbatim}

Podobně jako \texttt{regex()} je i~ve funkci \texttt{fixed()} možné vypnout rozdíl mezi malými a velkými písmeny pomocí parametru \texttt{ignore\_case}.

Funkce \texttt{fixed()} porovnává řetězec doslovně, takže znaky bere doslovně jako byty, což nemusí vždy správně fungovat pro znaky, které nejsou součástí kódu ASCII (zhruba pro znaky, které nejsou součástí anglické abecedy). Pokud chceme takové znaky brát doslovně, je potřeba použít funkci \texttt{cols()}, které je navíc možné nastavit \emph{locale} jazyka (implicitní jazyk je angličtina).

Poslední funkce pro modifikaci chování regulárních výrazů je funkce \texttt{boundary()}, která umožňuje nastavit okraje regulárního výrazu. Platné volby jsou ``character'', ``line\_break'', ``sentence'' a ``word''). Nejužitečnější je ~\texttt{boundary("word")}, které hledá hranice mezi slovy:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{s4 }\OtherTok{\textless{}{-}} \StringTok{"Svítilo zářilo zlaté slunce na pobřeží na lagunce."}
\FunctionTok{str\_split}\NormalTok{(s4, }\FunctionTok{boundary}\NormalTok{(}\StringTok{"word"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "Svítilo" "zářilo"  "zlaté"   "slunce"  "na"      "pobřeží" "na"     
## [8] "lagunce"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str\_extract\_all}\NormalTok{(s4, }\FunctionTok{boundary}\NormalTok{(}\StringTok{"word"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## [1] "Svítilo" "zářilo"  "zlaté"   "slunce"  "na"      "pobřeží" "na"     
## [8] "lagunce"
\end{verbatim}

\hypertarget{co-je-to-tidyverse}{%
\chapter{Co je to tidyverse?}\label{co-je-to-tidyverse}}

\emph{tidyverse} je soubor balíků obashujících všechny nástroje potřebné pro základní úkony v datové analýze. Balíky z \emph{tidyverse} Vám umožní:

\begin{itemize}
\tightlist
\item
  načíst data (balík \emph{reader}, \emph{haven}, \emph{xml2}, \emph{rvest} a další),
\item
  přeskládat je do požadované formy (balík \emph{tidyr}),
\item
  modifikovat je (balík \emph{dplyr})
\item
  a vizualizovat (balík \emph{ggplot2}).
\end{itemize}

Součástí \emph{tidyverse} jsou i další balíky. Některé z nich Vám jsou již známé (např. \emph{purrr}, \emph{stringr}, \emph{forcats} nebo \emph{tibble}). Všechny balíky v \emph{tidyverse} sdílejí logiku ovládání a datové struktury. Dohromady tak poskytují uživateli dobře provázané, kooperující a moderní prostředí pro datovou analýzu. Nevýhodou \emph{tidyverse} je, že jejich vývoj stále není zcela ukončen a dohcází v něm k zásadním změnám.

Balíky z tidyverse je možné načítat jednotlivě podle potřeby, nebo načtením metabalíku \emph{tidyverse}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(tidyverse)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## -- Attaching packages ----------------------------------------------------------------------------- tidyverse 1.3.1 --
\end{verbatim}

\begin{verbatim}
## v ggplot2 3.3.5     v purrr   0.3.4
## v tibble  3.1.2     v dplyr   1.0.7
## v tidyr   1.1.3     v stringr 1.4.0
## v readr   2.0.0     v forcats 0.5.1
\end{verbatim}

\begin{verbatim}
## -- Conflicts -------------------------------------------------------------------------------- tidyverse_conflicts() --
## x dplyr::filter() masks stats::filter()
## x dplyr::lag()    masks stats::lag()
\end{verbatim}

\hypertarget{pruxe1ce-s-tidyverse}{%
\section{Práce s tidyverse}\label{pruxe1ce-s-tidyverse}}

\hypertarget{trubkypipes}{%
\subsection{Trubky/pipes}\label{trubkypipes}}

S pomocí \emph{tidyverse} je možné psát velmi dobře srozumitelný kód. Hadley Wickham, který stojí za vytvořením podstatné části \emph{tidyverse}, při popisu balíků mluví o konceptu ``gramatiky práce s daty'' a ``gramatice vizualizace dat''.

Průběh datové analýzy můžeme popsat jako sekvenci úkonů. Například:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Načti data.
\item
  Vezmi načtenou tabulku a vyber z ní několik sloupců.
\item
  Vezmi upravenou tabulku a vyber pouze řádky, které splňují určité podmínky.
\item
  Vezmi upravenou tabulku a na jejím základě vykresli obrázek.
\item
  Výsledek ulož do proměnné \texttt{x}.
\end{enumerate}

Každý krok přitom využívá výsledek kroku předchozího. Pro podobné řetezení kroků využívá \emph{tidyverse} speciální funkci \texttt{\%\textgreater{}\%} (tzv. trubku/pipe), které spojuje dva kroky. Výstup prvního kroku vkládá jako vstup do následujícího kroku. Předchozí sekvenci kroků bychom tedy mohli schématicky zapsat následujícím způsobem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{read\_tsv}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%}  \CommentTok{\# Načti data}
  \FunctionTok{select}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%}       \CommentTok{\# Vyber sloupce}
  \FunctionTok{filter}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%}       \CommentTok{\# Vyber řádky}
  \FunctionTok{ggplot}\NormalTok{()           }\CommentTok{\# Vykresli data}
\end{Highlighting}
\end{Shaded}

Ukázka kódu není funkční -- funkce nemají zadané žádné parametry, ale ukazuje logiku celého přístupu. Výsledný kód svou strukturou připomíná strukturu psaného jazyka. Intrukce přehledně plyne zleva do prava, podobně jako text v knize.

Bez použití funkce \texttt{\%\textgreater{}\%} by postup vypadal následovně:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{read\_tsv}\NormalTok{()}
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{select}\NormalTok{(x)}
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{filter}\NormalTok{(x)}
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{ggplot}\NormalTok{(x)}
\end{Highlighting}
\end{Shaded}

Výsledek by byl zcela identický (a provedení kódu u velkých tabulek o maličko rychlejší). Výhodou trubek je však čitelnost a přehlednost. Praxe ukazuje, že mít jasný a čístý kód je v praxi datové analýzy často důležitější než marginální ztráta rychlosti.

V tomto kurzu budeme od této chvíle často používat funkci \texttt{\%\textgreater{}\%}. Pokud si oblíbíte používání trubek, můžete se podívat na balík \texttt{magrittr}, který kromě \texttt{\%\textgreater{}\%} implementuje i další trubkoidní funkce.

\hypertarget{placeholder-.}{%
\subsubsection{Placeholder ``.''}\label{placeholder-.}}

Funkce \texttt{\%\textgreater{}\%} ja nastavená tak, že obsah, který ji protéká vždy umisťuje do prvního parametru přijímající funkce. To je skoro vždy žádoucí chování, ale ne vždy. Modifikovat je ho možné s použítím symbolu \texttt{.}, který určuje místo, na které má trubka přenášený obsah umístit.

Můžeme si například představit situaci, kdy máme vektory \texttt{x} a \texttt{w}. Chceme spočítát vážený průměr \texttt{x}, ale trubkou nám putuje vektor vah \texttt{w}. Požadovaného výsledku dosáhneme takto:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{w }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{weighted.mean}\NormalTok{(x,.)}
\end{Highlighting}
\end{Shaded}

\hypertarget{subsetovuxe1nuxed}{%
\subsection{Subsetování}\label{subsetovuxe1nuxed}}

\emph{tidyverse}, konkrétně balík \emph{dplyr} obsahuje funkce pro subsetování. Zběžně se nyní seznámí s funkcí \texttt{select()}, která slouží k výběru sloupců. Na jejím příkladě si ukážeme, jak se v \emph{tidyverse} zachází se jmény sloupců.

Základní syntaxe \texttt{select()} je triviální:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{select}\NormalTok{(.data, ...)}
\end{Highlighting}
\end{Shaded}

Prvním parametrem je vstupní tabulka. V parametru \texttt{...} jsou specifikovány sloupce.

Jako ukázkovou tabulku budeme používat \texttt{us\_rent\_income} z balíku \emph{tidyr}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{us\_rent\_income}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 104 x 5
##    GEOID NAME       variable estimate   moe
##    <chr> <chr>      <chr>       <dbl> <dbl>
##  1 01    Alabama    income      24476   136
##  2 01    Alabama    rent          747     3
##  3 02    Alaska     income      32940   508
##  4 02    Alaska     rent         1200    13
##  5 04    Arizona    income      27517   148
##  6 04    Arizona    rent          972     4
##  7 05    Arkansas   income      23789   165
##  8 05    Arkansas   rent          709     5
##  9 06    California income      29454   109
## 10 06    California rent         1358     3
## # ... with 94 more rows
\end{verbatim}

Poznámka: Speciální metody výběru sloupců jsou implementovány v balíku \emph{tidyselect}, Ten si však nemusíte vždy loadovat. Balíky z \emph{tidyverse} si vše vyřeší samy.

\hypertarget{non-standard-evaluation-a-identifikace-jmuxe9nem-sloupce}{%
\subsubsection{Non-standard evaluation a identifikace jménem sloupce}\label{non-standard-evaluation-a-identifikace-jmuxe9nem-sloupce}}

\emph{tidyverse} používá tzv. nestandardní evaluaci. Ta je výhodná zvláště při interaktivní práci s daty. Praktickým dopadem je, že se jména sloupců píšou bez úvozovek. První možností jak identifikovat sloupec je tedy jménem bez úvozovek. Můžeme vybrat jeden:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{us\_rent\_income }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(variable)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 104 x 1
##    variable
##    <chr>   
##  1 income  
##  2 rent    
##  3 income  
##  4 rent    
##  5 income  
##  6 rent    
##  7 income  
##  8 rent    
##  9 income  
## 10 rent    
## # ... with 94 more rows
\end{verbatim}

Nebo více sloupců:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{us\_rent\_income }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(variable,estimate)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 104 x 2
##    variable estimate
##    <chr>       <dbl>
##  1 income      24476
##  2 rent          747
##  3 income      32940
##  4 rent         1200
##  5 income      27517
##  6 rent          972
##  7 income      23789
##  8 rent          709
##  9 income      29454
## 10 rent         1358
## # ... with 94 more rows
\end{verbatim}

\hypertarget{identifikace-pozicuxed}{%
\subsubsection{Identifikace pozicí}\label{identifikace-pozicuxed}}

Vedle jména je možné pro identifikaci sloupce použít číslo jeho pozice:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{us\_rent\_income }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{2}\NormalTok{,}\DecValTok{4}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 104 x 3
##    GEOID NAME       estimate
##    <chr> <chr>         <dbl>
##  1 01    Alabama       24476
##  2 01    Alabama         747
##  3 02    Alaska        32940
##  4 02    Alaska         1200
##  5 04    Arizona       27517
##  6 04    Arizona         972
##  7 05    Arkansas      23789
##  8 05    Arkansas        709
##  9 06    California    29454
## 10 06    California     1358
## # ... with 94 more rows
\end{verbatim}

\hypertarget{speciuxe1lnuxed-funkce}{%
\subsubsection{Speciální funkce}\label{speciuxe1lnuxed-funkce}}

Funkce, které potřebují specifikaci sloupců umí pracovat se speciálními funkcemi, které budou fungovat pouze v jejich rámci. Základní speciální funkce jsou dvě: \texttt{-} a \texttt{:}.

Funkce \texttt{-} umožňuje negativní výběr -- ``vyber všechno až na''. Následující volání funkce \texttt{select()} tak vrátí všechny sloupce až na \texttt{GEOID} a \texttt{NAME}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{us\_rent\_income }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\SpecialCharTok{{-}}\NormalTok{GEOID,}\SpecialCharTok{{-}}\NormalTok{NAME)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 104 x 3
##    variable estimate   moe
##    <chr>       <dbl> <dbl>
##  1 income      24476   136
##  2 rent          747     3
##  3 income      32940   508
##  4 rent         1200    13
##  5 income      27517   148
##  6 rent          972     4
##  7 income      23789   165
##  8 rent          709     5
##  9 income      29454   109
## 10 rent         1358     3
## # ... with 94 more rows
\end{verbatim}

Funkce \texttt{:} umožňuje specifikovat rozsah sloupců. To lze využít pokud chceme například vybrat sloupce \texttt{GEOID} a všechny sloupce mezi \texttt{variable} a \texttt{moe}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{us\_rent\_income }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(GEOID, variable}\SpecialCharTok{:}\NormalTok{moe)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 104 x 4
##    GEOID variable estimate   moe
##    <chr> <chr>       <dbl> <dbl>
##  1 01    income      24476   136
##  2 01    rent          747     3
##  3 02    income      32940   508
##  4 02    rent         1200    13
##  5 04    income      27517   148
##  6 04    rent          972     4
##  7 05    income      23789   165
##  8 05    rent          709     5
##  9 06    income      29454   109
## 10 06    rent         1358     3
## # ... with 94 more rows
\end{verbatim}

Speciální funkce fungují i při identifikace sloupců jejich pozicí\ldots{}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{us\_rent\_income }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\SpecialCharTok{{-}}\DecValTok{1}\NormalTok{,}\SpecialCharTok{{-}}\DecValTok{2}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 104 x 3
##    variable estimate   moe
##    <chr>       <dbl> <dbl>
##  1 income      24476   136
##  2 rent          747     3
##  3 income      32940   508
##  4 rent         1200    13
##  5 income      27517   148
##  6 rent          972     4
##  7 income      23789   165
##  8 rent          709     5
##  9 income      29454   109
## 10 rent         1358     3
## # ... with 94 more rows
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{us\_rent\_income }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{3}\SpecialCharTok{:}\DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 104 x 4
##    GEOID variable estimate   moe
##    <chr> <chr>       <dbl> <dbl>
##  1 01    income      24476   136
##  2 01    rent          747     3
##  3 02    income      32940   508
##  4 02    rent         1200    13
##  5 04    income      27517   148
##  6 04    rent          972     4
##  7 05    income      23789   165
##  8 05    rent          709     5
##  9 06    income      29454   109
## 10 06    rent         1358     3
## # ... with 94 more rows
\end{verbatim}

\ldots a je možné je kombinovat

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{us\_rent\_income }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\SpecialCharTok{{-}}\NormalTok{variable}\SpecialCharTok{:{-}}\NormalTok{moe)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 104 x 2
##    GEOID NAME      
##    <chr> <chr>     
##  1 01    Alabama   
##  2 01    Alabama   
##  3 02    Alaska    
##  4 02    Alaska    
##  5 04    Arizona   
##  6 04    Arizona   
##  7 05    Arkansas  
##  8 05    Arkansas  
##  9 06    California
## 10 06    California
## # ... with 94 more rows
\end{verbatim}

\hypertarget{funkce-pomocnuxedux10dci-select-helpers}{%
\subsubsection{Funkce pomocníčci: select helpers}\label{funkce-pomocnuxedux10dci-select-helpers}}

Balík \emph{tidyselect} obshauje funkce, které umožňují identifikovat sloupce jinak než přímým zadáním jména nebo pozice:

\begin{itemize}
\tightlist
\item
  \texttt{starts\_with()} vybírá sloupce, jejichž jméno začíná na řetězec, který je argumentem funkce \texttt{starts\_with()}
\item
  \texttt{ends\_with()} vybírá sloupce, jejichž jméno končí na řetězec, který je argumentem funkce \texttt{ends\_with()}
\item
  \texttt{contains()} vybírá sloupce, jejichž jméno obsahuje řetězec, který je argumentem funkce \texttt{contains()}
\item
  \texttt{matches()} vybírá sloupce, jejichž jméno odpovídá zadanému regulárnímu výrazu
\item
  \texttt{num\_range()} slouží pro výběr sloupců, jejichž jméno je tvořeno kombinací řetězce a čísla -- například \texttt{trial\_1}, \texttt{trial\_2},\ldots{}
\item
  \texttt{one\_of()} vrátí sloupce, jejichž jména jsou obsažena ve vektoru, který je vstupem funkce
\item
  \texttt{everything()} vrací všechny sloupce
\item
  \texttt{last\_col()} vrací poslední sloupec
\end{itemize}

Tyto funkce opět fungují jenom ``uvnitř'' kompatibilních funkcí. K subsetování se v mírně větším detailu vrátíme znovu v kapitole věnované balíku \emph{dplyr}.

\hypertarget{kap:tidyr}{%
\chapter{\texorpdfstring{Správně formátovaná data a balík \texttt{tidyr}}{Správně formátovaná data a balík tidyr}}\label{kap:tidyr}}

\emph{``It is often said that 80 \% of data analysis is spent on the cleaning and preparing data.''}

\emph{``Tidy datasets are all alike but every messy dataset is messy in its own way.''}

-- Hadley Wickham

Představte si výzkum vývoje dětí. Z populace si vybereme vzorek dětí, které budeme sledovat a následně u každého z nich každý měsíc naměříme řadu ukazatelů: výšku, váhu, počet červených krvinek, motorické a kognitivní schopnosti, počet prstů, atp.

Získáme tak soubor dat s mnoha pozorováními a mnoha dimenzemi. Jedno pozorování můžeme chápat jako moment měření -- definuje ho tedy identita pozorovaného subjektu (průřezová jednotka) a čas pozorování (věk). Každá sledovaná charakteristika potom představuje samostatnou dimenzi.

Množství pozorování a dimenzí umožňuje nejrůznější organizaci naměřených dat. Data jsou typicky organizována do formátu pravoúhlé tabulky, kde jsou data zapsána v buňkách organizovaných v řádcích a sloupcích. Tabulky však mohou být různě vnitřeně organizované. Mohou se lišit v tom, které údaje se zapisují do sloupců, které do řádků a podobně

V této lekci se naučíte:

\begin{itemize}
\tightlist
\item
  Jak vhodně organizovat data do tabulek -- tzv. \emph{tidy} formát
\item
  S pomocí nástrojů z balíku \emph{tidyr} upravovat data do \emph{tidy} formátu
\end{itemize}

Balík \emph{tidyr} je součástí \emph{tidyverse} a je třeba si ho nejprve načíst do paměti.

\hypertarget{sec:tidy-data-def}{%
\section{Tidy data}\label{sec:tidy-data-def}}

Formát \emph{``tidy data''} popisuje organizační strukturu dat v tabulkách. Data v tidy formátu splňují následující charakteristiky:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Každé pozorování je popsáno jedním řádkem
\item
  Každá proměnná je obsažena v jednom sloupci
\item
  Každý typ pozorování má vlastní tabulku
\end{enumerate}

Wickham (2016) ilustruje tidy fromát pomocí následujícího schématu:

\begin{figure}
\centering
\includegraphics[width=1\textwidth,height=\textheight]{figs/tidyr/tidy-1.png}
\caption{Struktura tidy dat (Wickham, 2016)}
\end{figure}

Uvažujme příklad statistik o trhu práce. Statistický úřad sleduje na roční bázi počet nezaměstnaných a velikost dopělé populace pro obce, okresy a kraje. Pokud by ukládal data v tidy struktuře potom by:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Data byla skladována ve třech tabulkách -- v jedné tabulce by byly údaje pro kraje, v druhé pro okresy a ve třetí pro obce.
\item
  Struktura každé tabulky by byla následující:
\end{enumerate}

\begin{verbatim}
## # A tibble: 6 x 4
##   area        year adult_population unemployment_rate
##   <chr>      <int>            <dbl>             <dbl>
## 1 Kostelec    2001              301               7  
## 2 Kostelec    2002              305               8.3
## 3 Kostelec    2003              295               6.4
## 4 Valtrovice  2001              656               6.8
## 5 Valtrovice  2002              650               7.8
## 6 Valtrovice  2003              660               6.7
\end{verbatim}

Každé pozorování je identifikováno správní jednotkou (\texttt{area}) a rokem (\texttt{year}). Každá sledovaná proměnná je potom uložena ve vlastním sloupci.

\hypertarget{transformace-tabulek-do-tidy-formuxe1tu}{%
\section{Transformace tabulek do tidy formátu}\label{transformace-tabulek-do-tidy-formuxe1tu}}

Ne všechny dostupné datasety jsou organizované v tidy formátu. Součástí \emph{tidyverse} je balíček \emph{tidyr}, který obsahuje nástroje pro transformaci tabulek do tidy formátu.

Základními funkcemi v balíku \emph{tidyr}, které zvládnou většinu obvyklých problémů, jsou \texttt{pivot\_wider()} a \texttt{pivot\_longer()}.

\hypertarget{poznuxe1mka-1}{%
\subsubsection{Poznámka 1}\label{poznuxe1mka-1}}

Funkce \texttt{pivot\_wider()} a \texttt{pivot\_longer()} přišly do \emph{tidyr} od verze 1.0.0 (podzim 2019). Ve streších verzích balíku jejich funkci plnily funkce \texttt{gather()} a \texttt{spread()}, které byly vlastně speciálním případem obecnějších \texttt{pivot\_}* funkcí. Funkce \texttt{gather()} a \texttt{spread()} byly v balíku podrženy pouze pro zachování zpětné kompatibility.

\hypertarget{poznuxe1mka-2}{%
\subsubsection{Poznámka 2}\label{poznuxe1mka-2}}

Existují balíky, které mají podobné funkcionality jako \emph{tidyr}. Zejména jde o \emph{reshape} a \emph{reshape2}. Oba balíky jsou v podstatě starými evolučními verzemi balíku \emph{tidyr}. Zejména \emph{reshape2} je stále v závislostech mnoha dalších balíků. \emph{tidyr} je však obecně pokročilejší (co do rychlosti, elegance i rozsahu funkcí).

\hypertarget{transformace-mnoha-sloupcux16f-do-jednoho-s-funkcuxed-pivot_longer}{%
\subsection{\texorpdfstring{Transformace mnoha sloupců do jednoho s funkcí \texttt{pivot\_longer()}}{Transformace mnoha sloupců do jednoho s funkcí pivot\_longer()}}\label{transformace-mnoha-sloupcux16f-do-jednoho-s-funkcuxed-pivot_longer}}

Mnoho datasetů obsahuje sloupce, jejichž jména nejsou samostatné proměnné, ale ve skutečnosti jde o hodnoty jedné proměnné. Jako příklad můžeme použít tabulku \texttt{table4a} z balíku \emph{tidyr}, která zachycuje počet pozorovaných případů v několika letech a zemích:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(table4a)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 3
##   country     `1999` `2000`
## * <chr>        <int>  <int>
## 1 Afghanistan    745   2666
## 2 Brazil       37737  80488
## 3 China       212258 213766
\end{verbatim}

V tomto formátu obsahuje jeden řádek hned dvě pozorování (dvě pozorování z jedné země) a dva sloupce obsahují stejnou proměnnou (počet případů). Pro transformaci takové tabulky do tidy formátu slouží funkce \texttt{pivot\_longer()}.

\texttt{pivot\_longer()} skládá hodnoty z vybraných sloupců do nově vytvořeného sloupce. Jména vybraných sloupců vytvoří další dodatečný sloupec. \texttt{pivot\_longer()} tak nahradí vybrané sloupce dvěma novými:

\includegraphics[width=0.4\textwidth,height=\textheight]{figs/tidyr/gather-1.png}
Výsledná tabulka je proto ``delší''. Pro snadnější zapamatování se se proto funkce jmenuje \texttt{pivot\_longer()}.

Ukázkou praktické aplikace \texttt{pivot\_longer()} může být transformace tabulky \texttt{table4a}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table4a }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{pivot\_longer}\NormalTok{(}\SpecialCharTok{{-}}\NormalTok{country)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 3
##   country     name   value
##   <chr>       <chr>  <int>
## 1 Afghanistan 1999     745
## 2 Afghanistan 2000    2666
## 3 Brazil      1999   37737
## 4 Brazil      2000   80488
## 5 China       1999  212258
## 6 China       2000  213766
\end{verbatim}

Funkce \texttt{pivot\_longer()} provedla transformaci ilustrovanou následujícím obrázkem:

\begin{figure}
\centering
\includegraphics{figs/tidyr/gather-2.png}
\caption{Fungování \texttt{gather()} (Wickham, 2016)}
\end{figure}

Původní tabulka měla 3 řádky. Nyní jich má 6. Každý původní řádek se rozpadl na dva nové.

Funkce \texttt{pivot\_longer()} má následující syntax a parametry (více viz \texttt{?pivot\_longer}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pivot\_longer}\NormalTok{(data, cols, }
             \AttributeTok{names\_to =} \StringTok{"name"}\NormalTok{, }
             \AttributeTok{names\_prefix =} \ConstantTok{NULL}\NormalTok{,}
             \AttributeTok{names\_sep =} \ConstantTok{NULL}\NormalTok{, }
             \AttributeTok{names\_pattern =} \ConstantTok{NULL}\NormalTok{, }
             \AttributeTok{names\_ptypes =} \FunctionTok{list}\NormalTok{(),}
             \AttributeTok{names\_repair =} \StringTok{"check\_unique"}\NormalTok{, }
             \AttributeTok{values\_to =} \StringTok{"value"}\NormalTok{,  }
             \AttributeTok{values\_drop\_na =} \ConstantTok{FALSE}\NormalTok{, }
             \AttributeTok{values\_ptypes =} \FunctionTok{list}\NormalTok{()}
\NormalTok{             )}
\end{Highlighting}
\end{Shaded}

Základní parametry jsou následující:
- \texttt{data}\ldots vstupní tabulka (data frame), která má projít transformací,
- \texttt{cols}\ldots identifikace sloupců, které mají být transformovány,
- \texttt{names\_to}\ldots jméno sloupce, který ve výsledné tabulce bude obsahovat jména transformovaných sloupců,
- \texttt{values\_to}\ldots jméno sloupce, který v transformované tabulce bude obsahovat hodnoty z původních sloupců.

Nyní se vraťme k úvodnímu příkladu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table4a }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{pivot\_longer}\NormalTok{(}\SpecialCharTok{{-}}\NormalTok{country)}
\end{Highlighting}
\end{Shaded}

Vstupem do funkce \texttt{pivot\_longer()} byla tabulka \texttt{table4a}. Parametr \texttt{cols} byl s využitím pomocné funkce \texttt{-} nastaven na hodnotu \texttt{-country}. To znamená, že transformovány byly všechny sloupce až na \texttt{country}. Nově vytvořená tabulka má tři sloupce: netransformovaný sloupec \texttt{country} a nově vytvořené sloupce \texttt{name} a \texttt{value}. Jména těchto sloupců jsou dána defaultním nastavením funkce \texttt{pivot\_longer()}.

Nyní se podíváme na složitější případ. Pro ilustraci upravenou tabulku \texttt{table4a}, které přidáme sloupec obsahující ID:

\begin{verbatim}
## # A tibble: 3 x 4
##   country     `1999` `2000`    id
## * <chr>        <int>  <int> <int>
## 1 Afghanistan    745   2666     1
## 2 Brazil       37737  80488     2
## 3 China       212258 213766     3
\end{verbatim}

Tabulku chceme transformovat tak, aby se sloupce s hodnotami (1999 a 2000) transformovaly do sloupců \texttt{year} a \texttt{value}. Je jasné, že chceme sáhnout po \texttt{pivot\_longer()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table4a }\SpecialCharTok{\%\textgreater{}\%} 
  \CommentTok{\# Tento řádek vytvoří nový sloupec s číslem řádku}
  \FunctionTok{mutate}\NormalTok{(}\AttributeTok{id =} \FunctionTok{row\_number}\NormalTok{()) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{pivot\_longer}\NormalTok{(}\SpecialCharTok{{-}}\NormalTok{country, }\SpecialCharTok{{-}}\NormalTok{id)}
\end{Highlighting}
\end{Shaded}

Toto nebude fungovat, protože parametr \texttt{cols} má jenom jednu pozici -- v jejím rámci musíme identifikovat všechny sloupce, které se mají transformovat.

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# Použití negativní identifikace}
\NormalTok{table4a }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{mutate}\NormalTok{(}\AttributeTok{id =} \FunctionTok{row\_number}\NormalTok{()) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{pivot\_longer}\NormalTok{(}\SpecialCharTok{{-}}\FunctionTok{c}\NormalTok{(country,id))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country        id name   value
##   <chr>       <int> <chr>  <int>
## 1 Afghanistan     1 1999     745
## 2 Afghanistan     1 2000    2666
## 3 Brazil          2 1999   37737
## 4 Brazil          2 2000   80488
## 5 China           3 1999  212258
## 6 China           3 2000  213766
\end{verbatim}

V tomto případě byl do jednomístného slotu vložen vektor vytvořený funkcí \texttt{c()}. Všiměte si, že i v něm jsou jména sloupců uvedena bez úvozovek.

Hint: V reálném nasazení je vždy užitečné zvážit použití negtivní identifikace sloupců. Představte si například situaci, kdy Vašim zdrojeme je databáze, do které každý rok přibude další sloupec. Pozitivní identifikace sloupců by způsobila, že Vaše skripty by po prvním updatu přestaly správně fungovat. Negativní identifikace tímto problémem netrpí.

Výše uvedená možnost není jediná možná. Následující příklady by vedly ke stejným výsledkům:

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{\# Použití pozitivní identifikace}
\NormalTok{table4a }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{mutate}\NormalTok{(}\AttributeTok{id =} \FunctionTok{row\_number}\NormalTok{()) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{pivot\_longer}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{\textasciigrave{}}\AttributeTok{1999}\StringTok{\textasciigrave{}}\NormalTok{,}\StringTok{\textasciigrave{}}\AttributeTok{2000}\StringTok{\textasciigrave{}}\NormalTok{))}

\CommentTok{\# Použití pozitivní identifikace a speciální funkce \textasciigrave{}:\textasciigrave{}}
\NormalTok{table4a }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{mutate}\NormalTok{(}\AttributeTok{id =} \FunctionTok{row\_number}\NormalTok{()) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{pivot\_longer}\NormalTok{(}\StringTok{\textasciigrave{}}\AttributeTok{1999}\StringTok{\textasciigrave{}}\SpecialCharTok{:}\StringTok{\textasciigrave{}}\AttributeTok{2000}\StringTok{\textasciigrave{}}\NormalTok{)}

\CommentTok{\# Použití select helpers}
\NormalTok{table4a }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{mutate}\NormalTok{(}\AttributeTok{id =} \FunctionTok{row\_number}\NormalTok{()) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{pivot\_longer}\NormalTok{(}\FunctionTok{matches}\NormalTok{(}\StringTok{"}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{d\{4\}"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\hypertarget{transformace-dvojice-sloupcux16f-do-mnoha-sloupcux16f-s-funkcuxed-pivot_wider}{%
\subsection{\texorpdfstring{Transformace dvojice sloupců do mnoha sloupců s funkcí \texttt{pivot\_wider()}}{Transformace dvojice sloupců do mnoha sloupců s funkcí pivot\_wider()}}\label{transformace-dvojice-sloupcux16f-do-mnoha-sloupcux16f-s-funkcuxed-pivot_wider}}

Funkce \texttt{pivot\_wider()} je inverzní k funkci \texttt{pivot\_longer()}. Použijeme ji v případě, že sloupec ve skutečnosti neobsahuje hodnoty jedné proměnné, ale hodnoty mnoha proměnných. Funkce \texttt{pivot\_wider()} transforumje dvojici sloupců do mnoha nových sloupců. Hodnoty prvního z původních sloupců obsahují určení proměnné a v druhém sloupci jsou uloženy jejich hodnoty.

Příkladem takového datasetu může být tabulka \texttt{table2} z balíku \emph{tidyr}:

\begin{verbatim}
## # A tibble: 12 x 4
##    country      year type            count
##    <chr>       <int> <chr>           <int>
##  1 Afghanistan  1999 cases             745
##  2 Afghanistan  1999 population   19987071
##  3 Afghanistan  2000 cases            2666
##  4 Afghanistan  2000 population   20595360
##  5 Brazil       1999 cases           37737
##  6 Brazil       1999 population  172006362
##  7 Brazil       2000 cases           80488
##  8 Brazil       2000 population  174504898
##  9 China        1999 cases          212258
## 10 China        1999 population 1272915272
## 11 China        2000 cases          213766
## 12 China        2000 population 1280428583
\end{verbatim}

Pozorování je opět identifikováno hodnotami ve sloupcích \texttt{country} a \texttt{year}. Nicméně jedno pozorování je roztaženo do dvou řádků a hodnoty pro počet případů (\texttt{count}) a velikost populace (\texttt{population}) jsou obsaženy v jednom sloupci \texttt{count}.

Pro převední takové tabulky do tidy fromátu je potřeba provést operaci popsanou následujícím schématem:

\begin{figure}
\centering
\includegraphics{figs/tidyr/spread-1.png}
\caption{Fungování \texttt{pivot\_wider()} (RStudio, 2015)}
\end{figure}

Funkce \texttt{pivot\_wider()} použije hodnoty z prvního sloupce (\texttt{key}) jako jména nově vytvořených sloupců. Nově vytvořené buňky jsou potom vyplněny hodnotami z druhého sloupce (\texttt{value}) v původní tabulce:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table2 }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{pivot\_wider}\NormalTok{(}\AttributeTok{names\_from =}\NormalTok{ type, }\AttributeTok{values\_from =}\NormalTok{ count)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year  cases population
##   <chr>       <int>  <int>      <int>
## 1 Afghanistan  1999    745   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       1999  37737  172006362
## 4 Brazil       2000  80488  174504898
## 5 China        1999 212258 1272915272
## 6 China        2000 213766 1280428583
\end{verbatim}

Funkce \texttt{pivot\_wider()} provedla transformaci ilustrovanou následujícím obrázkem:

\begin{figure}
\centering
\includegraphics{figs/tidyr/spread-2.png}
\caption{Fungování \texttt{pivot\_wider()} (Wickham, 2016)}
\end{figure}

Funkce \texttt{pivot\_wider()} má následující syntax a parametry (více viz \texttt{?pivot\_wider}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{pivot\_wider}\NormalTok{(data, }
            \AttributeTok{id\_cols =} \ConstantTok{NULL}\NormalTok{, }
            \AttributeTok{names\_from =}\NormalTok{ name, }
            \AttributeTok{names\_prefix =} \StringTok{""}\NormalTok{, }
            \AttributeTok{names\_sep =} \StringTok{"\_"}\NormalTok{, }
            \AttributeTok{names\_repair =} \StringTok{"check\_unique"}\NormalTok{,}
            \AttributeTok{values\_from =}\NormalTok{ value, }
            \AttributeTok{values\_fill =} \ConstantTok{NULL}\NormalTok{, }
            \AttributeTok{values\_fn =} \ConstantTok{NULL}
\NormalTok{            )}
\end{Highlighting}
\end{Shaded}

Klíčové parametry jsou následující:

\begin{itemize}
\tightlist
\item
  \texttt{data}\ldots vstupní tabulka (data frame), která má projít transformací
\item
  \texttt{id\_cols}\ldots sloupce, které identifikují jedno pozorování. V defaultní nastevením (tedy \texttt{NULL}) se k tomuto účelu použijí všechny sloupce, které neprocházejí transformací.
\item
  \texttt{names\_from}\ldots sloupec (nebo sloupce), ze kterého se mají vytvořit jména nově vytvořených sloupců,
\item
  \texttt{values\_from}\ldots sloupec (nebo sloupce), ze kterých se mají vzít hodnoty pro naplnění nově vytvořených sloupců.
\end{itemize}

Jak to funguje, pokud je parametr \texttt{names\_from} delší než 1?

Předpokládejme, že chceme vytvořit tabulku, ve které budou sloupce definovány kombinací roku a proměnné:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table2 }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{pivot\_wider}\NormalTok{(}\AttributeTok{names\_from =} \FunctionTok{c}\NormalTok{(type,year), }\AttributeTok{values\_from =}\NormalTok{ count)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 5
##   country     cases_1999 population_1999 cases_2000 population_2000
##   <chr>            <int>           <int>      <int>           <int>
## 1 Afghanistan        745        19987071       2666        20595360
## 2 Brazil           37737       172006362      80488       174504898
## 3 China           212258      1272915272     213766      1280428583
\end{verbatim}

Jméno sloupců je teď vytvořené z kombinace \texttt{type} a \texttt{year}. Výslednou podobu jmen upravuje parametr \texttt{names\_sep} z \texttt{pivot\_wider()}.

\hypertarget{praktickuxe9-procviux10denuxed-pivot_longer-a-pivot_wider-i}{%
\subsection{\texorpdfstring{Praktické procvičení \texttt{pivot\_longer()} a \texttt{pivot\_wider()} I}{Praktické procvičení pivot\_longer() a pivot\_wider() I}}\label{praktickuxe9-procviux10denuxed-pivot_longer-a-pivot_wider-i}}

Uvažujme tabulku vytvořenou v předchozím případě. Jak z ní vytvoříme tidy dataset?

Tabulka byla vytvořena s \texttt{pivot\_wider()}. V prvním kroku tedy sáhneme tedy po inverzní funkci \texttt{pivot\_longer()}.

V tomto příkladě využijeme řadu zatím nediskutovaných parametrů \texttt{pivot\_longer()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table2 }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{pivot\_wider}\NormalTok{(}\AttributeTok{names\_from =} \FunctionTok{c}\NormalTok{(type,year), }\AttributeTok{values\_from =}\NormalTok{ count) }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{pivot\_longer}\NormalTok{(}\SpecialCharTok{{-}}\NormalTok{country,}
                 \AttributeTok{names\_to =} \FunctionTok{c}\NormalTok{(}\StringTok{"type"}\NormalTok{,}\StringTok{"year"}\NormalTok{),}
                 \AttributeTok{names\_sep =} \StringTok{"\_"}\NormalTok{,}
                 \AttributeTok{names\_transform =} \FunctionTok{list}\NormalTok{(}\AttributeTok{year =}\NormalTok{ as.integer),}
                 \AttributeTok{names\_ptypes =} \FunctionTok{list}\NormalTok{(}\AttributeTok{type =} \FunctionTok{character}\NormalTok{()),}
                 \AttributeTok{values\_to =} \StringTok{"count"}
\NormalTok{                 )}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 12 x 4
##    country     type        year      count
##    <chr>       <chr>      <int>      <int>
##  1 Afghanistan cases       1999        745
##  2 Afghanistan population  1999   19987071
##  3 Afghanistan cases       2000       2666
##  4 Afghanistan population  2000   20595360
##  5 Brazil      cases       1999      37737
##  6 Brazil      population  1999  172006362
##  7 Brazil      cases       2000      80488
##  8 Brazil      population  2000  174504898
##  9 China       cases       1999     212258
## 10 China       population  1999 1272915272
## 11 China       cases       2000     213766
## 12 China       population  2000 1280428583
\end{verbatim}

Co se v nově použitých parametrech stalo? Parametr \texttt{names\_to} je nyní délky 2. To znamená, že jména transformovaných sloupců se rozpadnou do dvou sloupců se zadanými jmény. Jak se má tento rozpad provést určuje parametr \texttt{names\_sep} (u složitějších případů \texttt{names\_pattern}). V současném nastavení říká, že znaky před \texttt{\_} mají být přeneseny do sloupce \texttt{type} a znaky za \texttt{\_} do sloupce \texttt{year}. Bylo by také vhodné, aby hodnoty ve sloupci \texttt{type} byly character a ve sloupci \texttt{year} integer. Tato konverze se nastavuje parametrem \texttt{names\_ptypes}. Ten obsahuje pojmenovaný list. Jména odpovídají jménům nově vytvořených sloupců ke ketrým je přiřazen prázdný vektor požadovaného datového typu.

Tato transformace zvrátila účinky \texttt{pivot\_wider()}. Nicméně data stále nejsou tidy. Potřebujeme mít dva nové sloupce \texttt{cases} a \texttt{population} s hodnotami ze sloupce \texttt{count}. A job for \texttt{pivot\_wider()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table2 }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{pivot\_wider}\NormalTok{(}\AttributeTok{names\_from =} \FunctionTok{c}\NormalTok{(type,year), }\AttributeTok{values\_from =}\NormalTok{ count) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{pivot\_longer}\NormalTok{(}\SpecialCharTok{{-}}\NormalTok{country, }
                 \AttributeTok{names\_to =} \FunctionTok{c}\NormalTok{(}\StringTok{"type"}\NormalTok{,}\StringTok{"year"}\NormalTok{), }
                 \AttributeTok{names\_sep =} \StringTok{"\_"}\NormalTok{,}
                 \AttributeTok{names\_transform =} \FunctionTok{list}\NormalTok{(}\AttributeTok{year =}\NormalTok{ as.integer),}
                 \AttributeTok{names\_ptypes =} \FunctionTok{list}\NormalTok{(}\AttributeTok{type =} \FunctionTok{character}\NormalTok{()),}
                 \AttributeTok{values\_to =} \StringTok{"count"}
\NormalTok{                 ) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{pivot\_wider}\NormalTok{(}
    \AttributeTok{id\_cols =} \FunctionTok{c}\NormalTok{(country,year), }\CommentTok{\# V tomto případě ekvivalenttní k NULL}
    \AttributeTok{names\_from =}\NormalTok{ type,}
    \AttributeTok{values\_from =}\NormalTok{ count}
\NormalTok{  )}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year  cases population
##   <chr>       <int>  <int>      <int>
## 1 Afghanistan  1999    745   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       1999  37737  172006362
## 4 Brazil       2000  80488  174504898
## 5 China        1999 212258 1272915272
## 6 China        2000 213766 1280428583
\end{verbatim}

\ldots and here we go.

Výsledek odpovídá formátu tidy data.

\hypertarget{dalux161uxed-funkce-z-tidyr}{%
\section{\texorpdfstring{Další funkce z \emph{tidyr}}{Další funkce z tidyr}}\label{dalux161uxed-funkce-z-tidyr}}

Kromě funkcí \texttt{pivot\_*()}, které jsou bezesporu nejvíce používané při čistění a transformaci dat, obsahuje \emph{tidyr} řadu dalších funkcí, které pomáhají s:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Odstraněním méně obvyklých případů při transformaci tabulek do tidy fromátu.
\item
  Nakládáním s chybějícími hodnotami.
\item
  Konstrukcí vlastních tabulek.
\end{enumerate}

\hypertarget{rux16fznuxe9-typy-pozorovuxe1nuxed-v-jednuxe1-tabulce-nest-a-unnest}{%
\subsection{\texorpdfstring{Různé typy pozorování v jedná tabulce: \texttt{nest()} a \texttt{unnest()}}{Různé typy pozorování v jedná tabulce: nest() a unnest()}}\label{rux16fznuxe9-typy-pozorovuxe1nuxed-v-jednuxe1-tabulce-nest-a-unnest}}

Definice tidy formátu vyžaduje, aby byl každý typ pozorování uchován v oddělené tabulce.

Tabulka \texttt{population\_world} obsahuje data, která toto kritérium nesplňují. Obsahuje pozorování jak za jednotlivá pozorování, tak jejich agregované hodnoty:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(population\_world)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 9 x 5
##   country observation  year Female  Male
##   <chr>   <chr>       <int>  <dbl> <dbl>
## 1 Iceland unit         2005   148.  149.
## 2 Iceland unit         2010   158.  160.
## 3 Iceland unit         2015   164.  165.
## 4 Malta   unit         2005   201.  196.
## 5 Malta   unit         2010   207.  205.
## 6 Malta   unit         2015   210.  208.
## 7 World   aggregate    2005   348.  346.
## 8 World   aggregate    2010   365.  365.
## 9 World   aggregate    2015   375.  374.
\end{verbatim}

Pomocí funkce \texttt{nest()} je možné vytvořit datovou strukturu, která tento problém vyřeší. \texttt{nest()} vytvoří ``tabulku tabulek''. Můžeme ji použít pro vytvoření tabulky, která bude obsahovat jednotlivé tabulky v tidy formátu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{population\_world\_nested }\OtherTok{\textless{}{-}}\NormalTok{ population\_world }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{nest}\NormalTok{(}\AttributeTok{data =} \SpecialCharTok{{-}}\NormalTok{observation)}

\FunctionTok{print}\NormalTok{(population\_world\_nested)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 2 x 2
##   observation data            
##   <chr>       <list>          
## 1 unit        <tibble [6 x 4]>
## 2 aggregate   <tibble [3 x 4]>
\end{verbatim}

Tabulky v tidy formátu jsou obsaženy v nově vytvořeném sloupci \texttt{data}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(population\_world\_nested}\SpecialCharTok{$}\NormalTok{data)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [[1]]
## # A tibble: 6 x 4
##   country  year Female  Male
##   <chr>   <int>  <dbl> <dbl>
## 1 Iceland  2005   148.  149.
## 2 Iceland  2010   158.  160.
## 3 Iceland  2015   164.  165.
## 4 Malta    2005   201.  196.
## 5 Malta    2010   207.  205.
## 6 Malta    2015   210.  208.
## 
## [[2]]
## # A tibble: 3 x 4
##   country  year Female  Male
##   <chr>   <int>  <dbl> <dbl>
## 1 World    2005   348.  346.
## 2 World    2010   365.  365.
## 3 World    2015   375.  374.
\end{verbatim}

Fungování \texttt{nest()} ilustruje následující diagram:

\begin{figure}
\centering
\includegraphics{figs/tidyr/nest-1.png}
\caption{Fungování \texttt{nest()}}
\end{figure}

Hlavním praktickým využitím \texttt{nest()} je vytvoření datové struktury, která může sloužit pro následnou datovou analýzu s pomocí nástrojů, které nejsou plně kompatibilní s logikou \emph{tidyverse}. Zejména u vysoce specializivaných aplikací je takových funkcí překvapivě mnoho. Na některé případy narazíme zejména na konci kurzu.

Syntaxe funkce \texttt{nest()} je velmi jednoduchá (viz \texttt{?nest}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{nest}\NormalTok{(data, ...)}
\end{Highlighting}
\end{Shaded}

\begin{itemize}
\tightlist
\item
  \texttt{data}\ldots vstupní tabulka (data frame)
\item
  \texttt{...}\ldots identifikace sloupců, které mají být součástí nově vytvořených (pod)tabulek. Podobně jako v případě \texttt{pivot\_longer()} lze využít více způsobů, jak sloupce specifikovat: select helpers, atp.
\end{itemize}

Základním způsobem identifikace sloupců je podle jejich jmen:

\begin{verbatim}
## # A tibble: 3 x 3
##   country observation data            
##   <chr>   <chr>       <list>          
## 1 Iceland unit        <tibble [3 x 3]>
## 2 Malta   unit        <tibble [3 x 3]>
## 3 World   aggregate   <tibble [3 x 3]>
\end{verbatim}

Jméno vektoru \texttt{data} se použije jako název nově vytvořeného sloupce. Pokud vektor nijak nepojmenujete, vrátí Vám \texttt{nest()} varování a nový sloupec pojmenuje právě \texttt{data}.

Na příkladech výše bylo ukázán příklad výběru sloupců s pomocí speciální funkce \texttt{-}. Funkční by měly být všechny způsoby identifikace podle \emph{tidyselect}.

Datovou strukturu vytvořenou funkcí \texttt{nest()} lze transformovat do původního stavu pomocí funkce \texttt{unnest()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{population\_world\_nested }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{unnest}\NormalTok{(data)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 9 x 5
##   observation country  year Female  Male
##   <chr>       <chr>   <int>  <dbl> <dbl>
## 1 unit        Iceland  2005   148.  149.
## 2 unit        Iceland  2010   158.  160.
## 3 unit        Iceland  2015   164.  165.
## 4 unit        Malta    2005   201.  196.
## 5 unit        Malta    2010   207.  205.
## 6 unit        Malta    2015   210.  208.
## 7 aggregate   World    2005   348.  346.
## 8 aggregate   World    2010   365.  365.
## 9 aggregate   World    2015   375.  374.
\end{verbatim}

Syntaxe funkce \texttt{unnest()} je následující:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{unnest}\NormalTok{(data, }
\NormalTok{       cols, }
\NormalTok{       ..., }
       \AttributeTok{keep\_empty =} \ConstantTok{FALSE}\NormalTok{, }
       \AttributeTok{ptype =} \ConstantTok{NULL}\NormalTok{,}
       \AttributeTok{names\_sep =} \ConstantTok{NULL}\NormalTok{, }
       \AttributeTok{names\_repair =} \StringTok{"check\_unique"}
\NormalTok{       )}
\end{Highlighting}
\end{Shaded}

Základní parametry jsou:
- \texttt{data}\ldots je vstupní tabulka,
- \texttt{cols}\ldots je parametr vymezující sloupce, které se mají transformovat (obsahujících tabulky, které se mají ``rozbalit'').

Funkce \texttt{nest()} a \texttt{unnest()} se od \emph{tidyr} 1.0.0 významně změnily. Navíc k nim přibyly bratříčci \texttt{chop()} a \texttt{unchop()}. Ty se od \texttt{nest()}/\texttt{unnest()} liší v tom, že nevytvářejí nový sloupec tabulek, ale ponechávají původní sloupce, jen transformují jejich obsah na vektor:

\begin{verbatim}
## # A tibble: 3 x 5
##   country observation        year      Female        Male
##   <chr>   <chr>       <list<int>> <list<dbl>> <list<dbl>>
## 1 Iceland unit                [3]         [3]         [3]
## 2 Malta   unit                [3]         [3]         [3]
## 3 World   aggregate           [3]         [3]         [3]
\end{verbatim}

Volba mezi \texttt{nest()}/\texttt{chop()} závisí čistě na potřebách následné analýzy.

\hypertarget{vuxedce-hodnot-v-jednuxe9-buux148ce}{%
\subsection{Více hodnot v jedné buňce}\label{vuxedce-hodnot-v-jednuxe9-buux148ce}}

Některé tabulky obsahují v jedné buňce hodnoty více proměnných. Jako příklad může sloužit tabulka \texttt{tidyr::table3}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(table3)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 3
##   country      year rate             
## * <chr>       <int> <chr>            
## 1 Afghanistan  1999 745/19987071     
## 2 Afghanistan  2000 2666/20595360    
## 3 Brazil       1999 37737/172006362  
## 4 Brazil       2000 80488/174504898  
## 5 China        1999 212258/1272915272
## 6 China        2000 213766/1280428583
\end{verbatim}

Ve sloupci \texttt{rate} je obsažen podíl počtu případů (cases) na celkové populaci (population). Proměnná \texttt{rate} je navíc nutně uložena jako text (\texttt{character}). S takovou proměnnou nelze rozumně pracovat. \emph{tidyr} obsahuje nástroje, pomocí kterých je možné taková data převést do tidy formátu, který vyžaduje, aby obsahem jedné buňky byla vždy hodnota právě jedné proměnné.

\hypertarget{rozdux11blenuxed-jednoho-sloupce-do-mnoha-se-separate}{%
\subsubsection{\texorpdfstring{Rozdělení jednoho sloupce do mnoha se \texttt{separate()}}{Rozdělení jednoho sloupce do mnoha se separate()}}\label{rozdux11blenuxed-jednoho-sloupce-do-mnoha-se-separate}}

Základní funkcí je \texttt{separate()}, která umožňuje jeden sloupec rozdělit do mnoha nových sloupců. V případě tabulky \texttt{table3} například rozdělit sloupec \texttt{rate} na nové sloupce \texttt{cases} (číslo před ``/'') a \texttt{population} (číslo za ``/''):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table3 }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{separate}\NormalTok{(rate, }\FunctionTok{c}\NormalTok{(}\StringTok{"cases"}\NormalTok{,}\StringTok{"population"}\NormalTok{), }\AttributeTok{sep=}\StringTok{"/"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year cases  population
##   <chr>       <int> <chr>  <chr>     
## 1 Afghanistan  1999 745    19987071  
## 2 Afghanistan  2000 2666   20595360  
## 3 Brazil       1999 37737  172006362 
## 4 Brazil       2000 80488  174504898 
## 5 China        1999 212258 1272915272
## 6 China        2000 213766 1280428583
\end{verbatim}

\texttt{separate()} provádí operaci ilustrovanou následujícím digramem:

\begin{figure}
\centering
\includegraphics{figs/tidyr/separate-1.png}
\caption{Fungování \texttt{separate()} (Wickham, 2016)}
\end{figure}

Funkce \texttt{separate()} má následující syntaxi a parametry (viz \texttt{?separate}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{separate}\NormalTok{(data, col, into, }\AttributeTok{sep =} \StringTok{"[\^{}[:alnum:]]+"}\NormalTok{, }\AttributeTok{remove =} \ConstantTok{TRUE}\NormalTok{,}
  \AttributeTok{convert =} \ConstantTok{FALSE}\NormalTok{, }\AttributeTok{extra =} \StringTok{"warn"}\NormalTok{, }\AttributeTok{fill =} \StringTok{"warn"}\NormalTok{, ...)}
\end{Highlighting}
\end{Shaded}

\begin{itemize}
\tightlist
\item
  \texttt{data}\ldots vstupní tabulka (data frame)
\item
  \texttt{col}\ldots specifikace sloupce, který se má rozdělit. Sloupec je specifikován jako jméno bez úvozovek.
\item
  \texttt{into}\ldots jména nově vytvářených sloupců specifikovaná jako vektor (character vector)
\item
  \texttt{sep}\ldots udává rozdělení vstupního sloupce na výstupní sloupce. Může být specifikován jako číslo (pozice, na které se hodnoty v buňce rozdělí) a zejména jako regulární výraz.
\item
  \texttt{remove}\ldots Má být vstupní sloupec zachován ve výstupní tabulce?
\item
  \texttt{convert}\ldots pokud je nastaveno na \texttt{TRUE}, potom se funkce pokusí o automatickou konverzi výstupních sloupců. Pokud by například byla tato možnost použita v případě \texttt{table3}, potom by výstupní sloupce byly konvertovány do celých čísel (integer).
\item
  \texttt{extra}\ldots udává, co se má stát, pokud vstupní řetezec obsahuje \emph{více} hodnot, než je specifikováno výstupních sloupců.
\item
  \texttt{fill}\ldots udává, co se má stát, pokud vstupní řetězec obsahuje \emph{méně} hodnot, než je specifikováno výstupních sloupců.
\end{itemize}

Při výchozím nastavení je parametr \texttt{extra} nastaven na hodnotu \texttt{warn}. To znamená, že v přítomnosti většího počtu hodnot než je specifikováno nově vytvářených sloupců vrátí \texttt{seprate()} varování a zahodí přebytečné hodnoty.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table3 }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{separate}\NormalTok{(rate, }\FunctionTok{c}\NormalTok{(}\StringTok{"cases"}\NormalTok{), }\AttributeTok{sep=}\StringTok{"/"}\NormalTok{, }\AttributeTok{remove=}\ConstantTok{FALSE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning: Expected 1 pieces. Additional pieces discarded in 6 rows [1, 2, 3, 4,
## 5, 6].
\end{verbatim}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year rate              cases 
##   <chr>       <int> <chr>             <chr> 
## 1 Afghanistan  1999 745/19987071      745   
## 2 Afghanistan  2000 2666/20595360     2666  
## 3 Brazil       1999 37737/172006362   37737 
## 4 Brazil       2000 80488/174504898   80488 
## 5 China        1999 212258/1272915272 212258
## 6 China        2000 213766/1280428583 213766
\end{verbatim}

Toto chování lze změnit. V případě nastavení \texttt{extra} na \texttt{drop} provede ve výsledku stejnou opraci, ale nevypíše varování. V případě nastavení parametru na \texttt{merge} rozdělí vstupní hodnotu pouze na stejný počet skupin, jako je zadáno výstupních sloupců. V následujícím případě bude tedy výstup (ve sloupci \texttt{cases}) stejný jako vstup (ve sloupci \texttt{rate}):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table3 }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{separate}\NormalTok{(rate, }\FunctionTok{c}\NormalTok{(}\StringTok{"cases"}\NormalTok{), }\AttributeTok{sep=}\StringTok{"/"}\NormalTok{, }\AttributeTok{extra=}\StringTok{"merge"}\NormalTok{, }\AttributeTok{remove=}\ConstantTok{FALSE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year rate              cases            
##   <chr>       <int> <chr>             <chr>            
## 1 Afghanistan  1999 745/19987071      745/19987071     
## 2 Afghanistan  2000 2666/20595360     2666/20595360    
## 3 Brazil       1999 37737/172006362   37737/172006362  
## 4 Brazil       2000 80488/174504898   80488/174504898  
## 5 China        1999 212258/1272915272 212258/1272915272
## 6 China        2000 213766/1280428583 213766/1280428583
\end{verbatim}

Může se také stát, že vstupní hondota obsahuje méně skupin, než je specifikováno výstupních sloupců. V následujícím příkladě se snaží \texttt{separate()} rozdělit údaje ze sloupce \texttt{rate} do tří nových sloupců:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table3 }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{separate}\NormalTok{(rate, }\FunctionTok{c}\NormalTok{(}\StringTok{"cases"}\NormalTok{,}\StringTok{"population"}\NormalTok{,}\StringTok{"witches"}\NormalTok{), }\AttributeTok{sep=}\StringTok{"/"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Warning: Expected 3 pieces. Missing pieces filled with `NA` in 6 rows [1, 2, 3,
## 4, 5, 6].
\end{verbatim}

\begin{verbatim}
## # A tibble: 6 x 5
##   country      year cases  population witches
##   <chr>       <int> <chr>  <chr>      <chr>  
## 1 Afghanistan  1999 745    19987071   <NA>   
## 2 Afghanistan  2000 2666   20595360   <NA>   
## 3 Brazil       1999 37737  172006362  <NA>   
## 4 Brazil       2000 80488  174504898  <NA>   
## 5 China        1999 212258 1272915272 <NA>   
## 6 China        2000 213766 1280428583 <NA>
\end{verbatim}

Vstupní data však obsahují pouze dva bloky. Při výchozím nastavení parametru \texttt{fill} (\texttt{warn}) vrátí \texttt{separate()} varování a vyplní sloupce zprava. Alternativní nastavení \texttt{right} a \texttt{left} nevrací varování, a vyplňují sloupce zprava respektive zleva:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table3 }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{separate}\NormalTok{(rate, }\FunctionTok{c}\NormalTok{(}\StringTok{"cases"}\NormalTok{,}\StringTok{"population"}\NormalTok{,}\StringTok{"witches"}\NormalTok{), }\AttributeTok{sep=}\StringTok{"/"}\NormalTok{, }\AttributeTok{fill=}\StringTok{"left"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 5
##   country      year cases population witches   
##   <chr>       <int> <chr> <chr>      <chr>     
## 1 Afghanistan  1999 <NA>  745        19987071  
## 2 Afghanistan  2000 <NA>  2666       20595360  
## 3 Brazil       1999 <NA>  37737      172006362 
## 4 Brazil       2000 <NA>  80488      174504898 
## 5 China        1999 <NA>  212258     1272915272
## 6 China        2000 <NA>  213766     1280428583
\end{verbatim}

Funkce \texttt{separate()} má blízké příbuzné v podobě funkcí \texttt{extract()} (pozor na maskování \texttt{extract} balíkem \texttt{magrittr}) a \texttt{separate\_rows()}.

\texttt{extract()} umožňuje specifikovat jednotlivé skupiny ve vstupním sloupci pomocí regulárních výrazů. Pokud některá skupina ve vstupním výrazu chybí, potom je ve výstupním sloupci kódována jako \texttt{NA}.

\texttt{separate\_rows()} nerozkládá vstupní řetězec do sloupců, ale do řádků:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table3 }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{separate\_rows}\NormalTok{(rate, }\AttributeTok{sep=}\StringTok{"/"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 12 x 3
##    country      year rate      
##    <chr>       <int> <chr>     
##  1 Afghanistan  1999 745       
##  2 Afghanistan  1999 19987071  
##  3 Afghanistan  2000 2666      
##  4 Afghanistan  2000 20595360  
##  5 Brazil       1999 37737     
##  6 Brazil       1999 172006362 
##  7 Brazil       2000 80488     
##  8 Brazil       2000 174504898 
##  9 China        1999 212258    
## 10 China        1999 1272915272
## 11 China        2000 213766    
## 12 China        2000 1280428583
\end{verbatim}

Použití \texttt{separate\_rows()} na \texttt{table3} nemá smysl. Hodí se například v situaci, kdy jsou v buňce obsaženy identifikátory více různých stavů. Praktickým příkladem může být údaj o zatržení různých checkboxů ve formuláři -- takto je obsahují např. CSV exportované z Google Forms.

\hypertarget{slouux10denuxed-mnoha-sloupcux16f-do-jednoho-s-unite}{%
\subsubsection{\texorpdfstring{Sloučení mnoha sloupců do jednoho s \texttt{unite()}}{Sloučení mnoha sloupců do jednoho s unite()}}\label{slouux10denuxed-mnoha-sloupcux16f-do-jednoho-s-unite}}

\emph{tidyr} obsahuje funkci, které umožňuje provádět inverzní operaci -- tedy slučovat více sloupců do jednoho. Tabulka \texttt{tidyr::table5} obsahuje rok pozorování rozložený na století a rok:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(table5)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country     century year  rate             
## * <chr>       <chr>   <chr> <chr>            
## 1 Afghanistan 19      99    745/19987071     
## 2 Afghanistan 20      00    2666/20595360    
## 3 Brazil      19      99    37737/172006362  
## 4 Brazil      20      00    80488/174504898  
## 5 China       19      99    212258/1272915272
## 6 China       20      00    213766/1280428583
\end{verbatim}

Kompletní letopočet můžeme složit pomocí funkce \texttt{unite()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table5 }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{unite}\NormalTok{(year,century,year, }\AttributeTok{sep=}\StringTok{""}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 3
##   country     year  rate             
##   <chr>       <chr> <chr>            
## 1 Afghanistan 1999  745/19987071     
## 2 Afghanistan 2000  2666/20595360    
## 3 Brazil      1999  37737/172006362  
## 4 Brazil      2000  80488/174504898  
## 5 China       1999  212258/1272915272
## 6 China       2000  213766/1280428583
\end{verbatim}

\texttt{unite()} má obdobné rozhraní a parametry jako funkce určené k rozdělování hodnot (viz \texttt{?unite}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{unite}\NormalTok{(data, col, ..., }\AttributeTok{sep =} \StringTok{"\_"}\NormalTok{, }\AttributeTok{remove =} \ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{itemize}
\tightlist
\item
  \texttt{data}\ldots vstupní tabulka (data frame)
\item
  \texttt{col}\ldots jméno nově vytvořeného sloupce (prosté jméno bez úvozovek)
\item
  \texttt{...}\ldots sloupce, ze kterých má být nově vytvořený sloupec vytvořen (viz \texttt{dplyr::select})
\item
  \texttt{sep}\ldots znak oddělující hodnoty z jednotlivých sloupců
\item
  \texttt{remove}\ldots mají být původní sloupce odstraněny?
\end{itemize}

\hypertarget{implicitnuxed-a-explicitnuxed-chybux11bjuxedcuxed-hodnoty}{%
\section{Implicitní a explicitní chybějící hodnoty}\label{implicitnuxed-a-explicitnuxed-chybux11bjuxedcuxed-hodnoty}}

Tabulky často nejsou úplné -- některá pozorování chybějí. Chybějící pozorování je účelné rozdělit na \emph{implicitní} a \emph{explicitní}.

Rozdíl mezi nimi je demonstrován na následujících tabulkách vytvořených z \texttt{table1}.

První tabulka \texttt{table1\_expl} obsahuje explicitní chybějící hodnoty. Pozorování (Brazílie v roce 1999) je v tabulce přítomno, ale místo naměřených hodnot vidíme \texttt{NA}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table1\_expl }\OtherTok{\textless{}{-}}\NormalTok{ table1}
\NormalTok{table1\_expl[table1\_expl}\SpecialCharTok{$}\NormalTok{country }\SpecialCharTok{==} \StringTok{"Brazil"} \SpecialCharTok{\&}\NormalTok{ table1\_expl}\SpecialCharTok{$}\NormalTok{year }\SpecialCharTok{==} \DecValTok{1999}\NormalTok{, }\FunctionTok{c}\NormalTok{(}\StringTok{"cases"}\NormalTok{,}\StringTok{"population"}\NormalTok{)] }\OtherTok{\textless{}{-}} \ConstantTok{NA}
\NormalTok{table1\_expl[table1\_expl}\SpecialCharTok{$}\NormalTok{country }\SpecialCharTok{==} \StringTok{"Afghanistan"} \SpecialCharTok{\&}\NormalTok{ table1\_expl}\SpecialCharTok{$}\NormalTok{year }\SpecialCharTok{==} \DecValTok{1999}\NormalTok{, }\StringTok{"cases"}\NormalTok{] }\OtherTok{\textless{}{-}} \ConstantTok{NA}

\FunctionTok{print}\NormalTok{(table1\_expl)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year  cases population
##   <chr>       <int>  <int>      <int>
## 1 Afghanistan  1999     NA   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       1999     NA         NA
## 4 Brazil       2000  80488  174504898
## 5 China        1999 212258 1272915272
## 6 China        2000 213766 1280428583
\end{verbatim}

Tabulka \texttt{table1\_impl} obsahuje implicitní chybějící hodnoty. Pozorování s nenaměřenými chybami v tabulce vůbec není přítomno:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table1\_impl }\OtherTok{\textless{}{-}}\NormalTok{ table1}
\NormalTok{table1\_impl }\OtherTok{\textless{}{-}}\NormalTok{ table1\_impl[}\SpecialCharTok{!}\NormalTok{(table1\_impl}\SpecialCharTok{$}\NormalTok{country }\SpecialCharTok{==} \StringTok{"Brazil"} \SpecialCharTok{\&}\NormalTok{ table1\_impl}\SpecialCharTok{$}\NormalTok{year }\SpecialCharTok{==} \DecValTok{1999}\NormalTok{),]}
    
\FunctionTok{print}\NormalTok{(table1\_impl)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 4
##   country      year  cases population
##   <chr>       <int>  <int>      <int>
## 1 Afghanistan  1999    745   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       2000  80488  174504898
## 4 China        1999 212258 1272915272
## 5 China        2000 213766 1280428583
\end{verbatim}

Implicitní chybějící hodnoty jsou při analýze dat velmi zákeřné -- nejsou viditelné ``pouhým okem'' a ani testem na přítomnost \texttt{NA}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{table1\_impl[}\SpecialCharTok{!}\FunctionTok{complete.cases}\NormalTok{(table1\_impl),]}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 0 x 4
## # ... with 4 variables: country <chr>, year <int>, cases <int>,
## #   population <int>
\end{verbatim}

\hypertarget{odstranux11bnuxed-implicitnuxedch-chybux11bjuxedcuxedch-hodnot-s-complete}{%
\subsubsection{\texorpdfstring{Odstranění implicitních chybějících hodnot s \texttt{complete()}}{Odstranění implicitních chybějících hodnot s complete()}}\label{odstranux11bnuxed-implicitnuxedch-chybux11bjuxedcuxedch-hodnot-s-complete}}

Při analýze dat je proto vhodné konvertovat implicitní chybějící hodnoty na explicitní. Pro tento účel je možné použít funkci \texttt{complete()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{complete}\NormalTok{(table1\_impl, country, year)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year  cases population
##   <chr>       <int>  <int>      <int>
## 1 Afghanistan  1999    745   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       1999     NA         NA
## 4 Brazil       2000  80488  174504898
## 5 China        1999 212258 1272915272
## 6 China        2000 213766 1280428583
\end{verbatim}

Syntaxe funkce \texttt{complete()} je velmi přímočará:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{complete}\NormalTok{(data, ..., }\AttributeTok{fill =} \FunctionTok{list}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{itemize}
\tightlist
\item
  \texttt{data}\ldots vstupní tabulka (data frame)
\item
  \texttt{...}\ldots sloupce, ze které definují (jednoznačně identifikují) pozorování (v příkladu výše \texttt{country} a \texttt{year})
\end{itemize}

Ve výchozím nastavení jsou implicitní chybějící hodnoty nahrazeny \texttt{NA}. Toto chování lze změnit parametrem \texttt{fill}. Můžeme například vědět, že pokud není žádný případ zaznamenán, tak statistický úřad pozorování nezapisuje -- i když by měl správně zapsat hodnotu 0. (Takto skutečně v některých případech postupuje ČSÚ.) Znalost dat nás tedy vede k tomu, že chybějící pozorování ve sloupci \texttt{cases} jsou ve skutečnosti nulová pozorování. Správně doplněné chybějící hodnoty je tedy možné získat nastavením parametru \texttt{fill}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{complete}\NormalTok{(table1\_impl, country, year, }\AttributeTok{fill =} \FunctionTok{list}\NormalTok{(}\AttributeTok{cases =} \DecValTok{0}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year  cases population
##   <chr>       <int>  <dbl>      <int>
## 1 Afghanistan  1999    745   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       1999      0         NA
## 4 Brazil       2000  80488  174504898
## 5 China        1999 212258 1272915272
## 6 China        2000 213766 1280428583
\end{verbatim}

Do parametru \texttt{fill} se vkládá \texttt{list} s pojmenovanými položkami. Jména položek musí odpovídat jménům sloupců v tabulce a musí obsahovat právě jednu hodnotu. Ta je použita pro nahrazení chybějících hodnot.

V příkladu výše zůstalo chybějící pozorování v \texttt{population} nahrazeno \texttt{NA}. Pokud není pravidlo pro náhradu explicitně stanoveno ve \texttt{fill}, zůstává v platnosti výchozí nastavení.

\hypertarget{odstranux11bnuxed-explicitnuxedch-chybux11bjuxedcuxedch-hodnot-s-drop_na}{%
\subsubsection{\texorpdfstring{Odstranění explicitních chybějících hodnot s \texttt{drop\_na()}}{Odstranění explicitních chybějících hodnot s drop\_na()}}\label{odstranux11bnuxed-explicitnuxedch-chybux11bjuxedcuxedch-hodnot-s-drop_na}}

V některých případech je naopak vhodné odstranit explicitní chybějící hodnoty a pracovat s tabulkou, ve které jsou implicitní chybějící hodnoty. Pro to je možné využít funkci \texttt{drop\_na()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{drop\_na}\NormalTok{(table1\_expl)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 4 x 4
##   country      year  cases population
##   <chr>       <int>  <int>      <int>
## 1 Afghanistan  2000   2666   20595360
## 2 Brazil       2000  80488  174504898
## 3 China        1999 212258 1272915272
## 4 China        2000 213766 1280428583
\end{verbatim}

Ve výchozím nastavení \texttt{drop\_na()} zahazuje všechny řádky, na nichž se vyskytla chybějící hodnota -- a to v libovolném sloupci. Toto chování lze změnit pomocí jediného dodatečného parametru funkce \texttt{...}, který umožňuje specifikovat, které sloupce mají být brány v potaz. Sloupce mohou být identifikovány všemi způsoby srozumitelnými pro \texttt{dplyr::select()}.

V následujícím příkladě je vypuštěn pouze řádek, ve kterém je chybějící hodnota ve sloupci \texttt{population}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{drop\_na}\NormalTok{(table1\_expl, population)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 4
##   country      year  cases population
##   <chr>       <int>  <int>      <int>
## 1 Afghanistan  1999     NA   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       2000  80488  174504898
## 4 China        1999 212258 1272915272
## 5 China        2000 213766 1280428583
\end{verbatim}

\hypertarget{nahrazenuxed-explicitnuxedch-chybux11bjuxedcuxedch-hodnot-s-fill-replace_na}{%
\subsubsection{\texorpdfstring{Nahrazení explicitních chybějících hodnot s \texttt{fill()}, \texttt{replace\_na()}}{Nahrazení explicitních chybějících hodnot s fill(), replace\_na()}}\label{nahrazenuxed-explicitnuxedch-chybux11bjuxedcuxedch-hodnot-s-fill-replace_na}}

První funkcí pro nahrazování explicitních chybějících pozorování je \texttt{replace\_na()}. Její syntaxe a fungování je analogické k parametru \texttt{fill} funkce \texttt{complete()}. (\texttt{complete()} je nakonec pouze wrapper okolo \texttt{replace\_na()} a několika dalších funkcí.)

Následující použití \texttt{replace\_na()} nahradí chybějící pozorování ve sloupci \texttt{cases} nulami a v \texttt{population} nekonečnem (\texttt{Inf}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{replace\_na}\NormalTok{(table1\_expl, }\AttributeTok{replace =} \FunctionTok{list}\NormalTok{(}\AttributeTok{cases =} \DecValTok{0}\NormalTok{, }\AttributeTok{population =} \ConstantTok{Inf}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year  cases population
##   <chr>       <int>  <dbl>      <dbl>
## 1 Afghanistan  1999      0   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       1999      0        Inf
## 4 Brazil       2000  80488  174504898
## 5 China        1999 212258 1272915272
## 6 China        2000 213766 1280428583
\end{verbatim}

\texttt{replace\_na()} je užitečná ve velmi omezeném množství případů (viz \texttt{complete()}). Častěji je pravděpoodbně v praxi využívána funkce \texttt{fill()}. \texttt{fill()} nahrazuje chybějící hodnotu hodnotou z předcházejícího (výchozí možnost) nebo následujícího řádku. Pozor, \texttt{fill()} pracuje pouze tehdy, pokud jsou chybějící hodnoty explicitní!

Funkci \texttt{fill()} je nutné v parametru \texttt{...} specifikovat sloupce, u kterých se má nahrazení chybějících hodnot provést. (\texttt{fill()} opět rozumí všem možnostem dostupným v \texttt{dplyr::select()}.) Následující ukázka demonstruje úskalí používání funkce \texttt{fill()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{fill}\NormalTok{(table1\_expl, cases)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 4
##   country      year  cases population
##   <chr>       <int>  <int>      <int>
## 1 Afghanistan  1999     NA   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       1999   2666         NA
## 4 Brazil       2000  80488  174504898
## 5 China        1999 212258 1272915272
## 6 China        2000 213766 1280428583
\end{verbatim}

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Chybějící hodnota v prvním řádku nebyla nahrazena -- neexistuje totiž žádný předcházející řádek.
\item
  Údaj pro Brazilii byl nahrazen údajem pro Afganistán.
\end{enumerate}

První problém samozřejmě nemá řešení. Výzkumník může zvážit nahrazení hodnotou z následujícího řádku (pomocí parametru \texttt{.direction\ =\ "up"}). Pro druhý problém je řešení následující:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Rozdělit tabulku na mnoho dílčích tabulek podél proměnné \texttt{country}.
\item
  Provést nahrazení v každé z nich.
\item
  Tabulky složit zpátky.
\end{enumerate}

Takový úkol je jistě proveditelný, ale velmi složitý. Naštěstí právě takovou funkcionalitu poskytuje \texttt{group\_by()} z balíku \texttt{dplyr}. \texttt{group\_by()} umožňuje každou definovanou skupinu zpracovat odděleně:

\begin{verbatim}
## # A tibble: 6 x 4
## # Groups:   country [3]
##   country      year  cases population
##   <chr>       <int>  <int>      <int>
## 1 Afghanistan  1999     NA   19987071
## 2 Afghanistan  2000   2666   20595360
## 3 Brazil       1999     NA         NA
## 4 Brazil       2000  80488  174504898
## 5 China        1999 212258 1272915272
## 6 China        2000 213766 1280428583
\end{verbatim}

V tomto případě je výsledek v pořádku -- Brazílie ``nedědí'' hodnoty Afganistánu.

\hypertarget{konstrukce-vlastnuxedch-tabulek-s-crossing}{%
\section{\texorpdfstring{Konstrukce vlastních tabulek s \texttt{crossing()}}{Konstrukce vlastních tabulek s crossing()}}\label{konstrukce-vlastnuxedch-tabulek-s-crossing}}

V některých případech je užitečné vytvořit si vlastní tabulku. Typickým příkladem může být vytvoření ``kostry'' tabulky, která bude obsahovat všechny možné varinty (identifikátory) pozorování, které se ve výsledné tabulce mohou vyskytnout.

Například můžeme chtít vytvořit panelová data pro země V4 a pro roky 2000--2001. Tento úkol je možné efektivně vyřešit pomocí \texttt{crossing()}:

\begin{verbatim}
## # A tibble: 8 x 2
##   country         year
##   <chr>          <int>
## 1 Czech Republic  2000
## 2 Czech Republic  2001
## 3 Hungary         2000
## 4 Hungary         2001
## 5 Poland          2000
## 6 Poland          2001
## 7 Slovakia        2000
## 8 Slovakia        2001
\end{verbatim}

\hypertarget{kap:dplyr}{%
\chapter{\texorpdfstring{Manipulace s daty s nástroji z balíku \emph{dplyr}}{Manipulace s daty s nástroji z balíku dplyr}}\label{kap:dplyr}}

Balík \emph{tidyr} obsahuje nástroje, které umožňují uživateli velmi jednoduše měnit organizační strukturu tabulky a provádět některé operace spojené s čištěním dat. Praktická práce s daty však vyžaduje více a to nejen v oblasti čištění dat. Typicky potřebujete subsetovat pozorování nebo proměnné, modifikovat nebo vytvářet nové proměnné a agregovat pozorování. Data také obvykle nejsou pouze v jediném zdroji -- tabulce. Je tedy nutné tabulky různými způsoby slučovat. Pro tyto úkoly existuje v R balík \emph{dplyr} -- součást \emph{tidyverse}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(tidyverse)}
\end{Highlighting}
\end{Shaded}

V této lekci se naučíte:

\begin{itemize}
\tightlist
\item
  subsetovat pozorování a proměnné
\item
  vytvářet nové a modifikovat stávající proměnné
\item
  vytvářet agregované hodnoty z více pozorování
\item
  provádět jednotlivé operace zvlášť pro různé skupiny pozorování
\item
  spojovat \emph{(join)} a slučovat \emph{(bind)} tabulky
\item
  a další\ldots{}
\end{itemize}

Funkcionalitu, kterou Vám poskytuje \emph{dplyr} můžete získat i s nástroji \emph{base} R. Nicméně používání \emph{dplyr} vám přinese snadnější interaktivní práci, vyšší rychlost (zejména pro ``středně velká'' data) a srozumitelnost kódu. Výhodou je i kompatibilita API s ostatními částmi \emph{tidyverse}.

Pro uživatele, kteří hodlají pracovat s velkými objemy dat (včetně Big Data), je důležitá i další možnost, kterou \emph{dplyr} nabízí. Kód napsaný v \emph{dplyr} může být vykonán s pomocí různých backendů -- nástrojů, které provádí samotnou práci s daty. Vedle základního (defaultního) backendu je k dispozici balík \emph{dtplyr}, který umožňuje vykonat kód s pomocí tříd a funkcí \texttt{data.table}, nebo balík \emph{dbplyr}, který umožňuje kód vnitřně přeložit do SQL a nechat ho vykonat vzdálenou databázi. Uživatelé, kteří mají k dispozici speciální infrastrukturu pro analýzu Big Data, mohou podobně využít i backend pro Apache Spark z balíku \emph{sparklyr}. Možnost změnit backend dělá z \emph{dplyr} mocný nástroj, protože umožňuje jednoduché škálování úloh.

\emph{dplyr} má implementováno mnoho dalších pokročilých funkcí. Obsahem této lekce jsou však spíše základy, které nicméně pokrývají vše, co je běžně potřeba pro interaktivní práci s daty. O \emph{dplyr} platí více než o všech jiných balících zmíněných v celém kurzu, že je stále ve velmi aktivním vývoji. Dochází k častým a hlubokým změnám jak v API, tak v backendu (respektive backendech). Tato kapitola byla připravována s požitím verze 1.0.0. Udržujte svůj \emph{dplyr} \textbf{aktualizovaný}. Určitě je také doporučeníhodné sledovat vývoj a čas od času si projít seznam zahrnutých funkcí.

\hypertarget{co-je-obsahem-baluxedku-dplyr}{%
\subsection{\texorpdfstring{Co je obsahem balíku \emph{dplyr}?}{Co je obsahem balíku dplyr?}}\label{co-je-obsahem-baluxedku-dplyr}}

Hadley Wickham používá pro označení skupin funkcí slovní druhy. Základním slovním druhem v balíku \emph{dplyr} je sloveso. \emph{dplyr} obsahuje slovesa (funkce), které pracují s jednou tabulkou (např. \emph{vyber}, \emph{seřaď}, nebo \emph{agreguj}), nebo (primárně) dvěma tabulkami (\emph{spoj} a \emph{sluč}).

Samostatnou funkcionalitou je schopnost \emph{dplyr} spouštět slovesa nejen nad celou jednou tabulkou, ale také nad jejími částmi (skupinami pozorování). Takové operace se nazývají ``zgrupované''.

Obsah přednášky:

\begin{itemize}
\tightlist
\item
  slovesa (funkce) pracující s jednou tabulkou
\item
  zgrupované operace
\item
  slovesa (funkce) pracující se dvěma (nebo více) tabulkami
\end{itemize}

Pro demonstraci funkcí z balíku \emph{dplyr} jsou použita data z balíku \emph{nycflights13} -- údaje o letech z/do NYC v roce 2013:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(nycflights13)}
\end{Highlighting}
\end{Shaded}

Ve většině příkladů budeme používat tabulku \texttt{planes} s údaji o letadlech, která do NYC létala:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%}\NormalTok{ print}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 9
##    tailnum  year type          manufacturer   model  engines seats speed engine 
##    <chr>   <int> <chr>         <chr>          <chr>    <int> <int> <int> <chr>  
##  1 N10156   2004 Fixed wing m~ EMBRAER        EMB-1~       2    55    NA Turbo-~
##  2 N102UW   1998 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  3 N103US   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  4 N104UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  5 N10575   2002 Fixed wing m~ EMBRAER        EMB-1~       2    55    NA Turbo-~
##  6 N105UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  7 N107US   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  8 N108UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  9 N109UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 10 N110UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## # ... with 3,312 more rows
\end{verbatim}

\hypertarget{poznuxe1mka}{%
\subsubsection{Poznámka}\label{poznuxe1mka}}

\emph{dplyr} je pokročilou evolucí balíku \texttt{plyr}. Balík \texttt{plyr} je stále v závislostech některých balíků, které využívají jeho služeb. To může (a pravděpodobně bude) vyvolávat konflikty, kterým se dá čelit jednoduchým způsobem -- vždy nejprve načíst \texttt{plyr} a až následně \emph{dplyr}. Pokud načtete balíky v opačném pořadí, tak Vám \emph{dplyr} vypíše upovídané varování. (Tento problém se v čase zmenšuje. Stále však taková situace může reálně nastat.)

\hypertarget{slovesa-pracujuxedcuxed-s-jednou-tabulkou}{%
\section{Slovesa pracující s jednou tabulkou}\label{slovesa-pracujuxedcuxed-s-jednou-tabulkou}}

\hypertarget{vuxfdbux11br-ux159uxe1dkux16f-pozorovuxe1nuxed}{%
\subsection{Výběr řádků (pozorování)}\label{vuxfdbux11br-ux159uxe1dkux16f-pozorovuxe1nuxed}}

Základní funkcí, která umožňuje výběr řádků je \texttt{filter()}. Podobně jako většina funkcí z balíku \emph{dplyr} má extrémně jednoduchou syntax:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{filter}\NormalTok{(.data, ...)}
\end{Highlighting}
\end{Shaded}

Vstupem funkce je tabulka (\texttt{.data}) a jeden nebo více logických predikátů. Výstupem funkce je podmnožina řádků, která splňuje všechny zadané predikáty.

Například se můžeme chtít podívat na letadla, která vyrobil Airbus nebo Boeing a mají více než dva motory:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{filter}\NormalTok{(manufacturer }\SpecialCharTok{\%in\%} \FunctionTok{c}\NormalTok{(}\StringTok{"AIRBUS INDUSTRIE"}\NormalTok{,}\StringTok{"BOEING"}\NormalTok{), engines }\SpecialCharTok{\textgreater{}} \DecValTok{2}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 2 x 9
##   tailnum  year type           manufacturer   model  engines seats speed engine 
##   <chr>   <int> <chr>          <chr>          <chr>    <int> <int> <int> <chr>  
## 1 N281AT     NA Fixed wing mu~ AIRBUS INDUST~ A340-~       4   375    NA Turbo-~
## 2 N670US   1990 Fixed wing mu~ BOEING         747-4~       4   450    NA Turbo-~
\end{verbatim}

Vybrány byly pouze řádky splňující všechny podmínky najednou. Následující volání \texttt{filter()}, které spojuje dvě výše použité podmínky do jedné logickým AND (\texttt{\&}) proto vrátí stejný výsledek:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{filter}\NormalTok{(manufacturer }\SpecialCharTok{\%in\%} \FunctionTok{c}\NormalTok{(}\StringTok{"AIRBUS INDUSTRIE"}\NormalTok{,}\StringTok{"BOEING"}\NormalTok{) }\SpecialCharTok{\&}\NormalTok{ engines }\SpecialCharTok{\textgreater{}} \DecValTok{2}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 2 x 9
##   tailnum  year type           manufacturer   model  engines seats speed engine 
##   <chr>   <int> <chr>          <chr>          <chr>    <int> <int> <int> <chr>  
## 1 N281AT     NA Fixed wing mu~ AIRBUS INDUST~ A340-~       4   375    NA Turbo-~
## 2 N670US   1990 Fixed wing mu~ BOEING         747-4~       4   450    NA Turbo-~
\end{verbatim}

Podmínky použité ve funkci \texttt{filter()} musí po vyhodnocení vracet logické hodnoty \texttt{TRUE}/\texttt{FALSE}. Ve \texttt{filter()} tedy můžeme používat funkce, které vracejí logickou hodnotu.

Například nás mohou zajímat všechna letadla z rodiny A340. Budeme tedy chtít vybrat všechny řádky, u nichž proměnná \texttt{model} začíná na ``A340''. Kromě balíku \emph{dplyr} budeme potřebovat i \emph{stringr}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(stringr)}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{filter}\NormalTok{(}\FunctionTok{str\_detect}\NormalTok{(model,}\StringTok{"\^{}A340"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1 x 9
##   tailnum  year type           manufacturer   model  engines seats speed engine 
##   <chr>   <int> <chr>          <chr>          <chr>    <int> <int> <int> <chr>  
## 1 N281AT     NA Fixed wing mu~ AIRBUS INDUST~ A340-~       4   375    NA Turbo-~
\end{verbatim}

Je možné používat i funkce, které nevracejí logické hodnoty. V takové případě je však nutné jejich výsledek na logickou proměnou transformovat. Řekněme, že by nás zajímala letadla, kde na jeden motor připadá méně než 10 sedadel:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{filter}\NormalTok{(seats}\SpecialCharTok{/}\NormalTok{engines }\SpecialCharTok{\textless{}} \DecValTok{10}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 39 x 9
##    tailnum  year type          manufacturer model   engines seats speed engine  
##    <chr>   <int> <chr>         <chr>        <chr>     <int> <int> <int> <chr>   
##  1 N201AA   1959 Fixed wing s~ CESSNA       150           1     2    90 Recipro~
##  2 N202AA   1980 Fixed wing m~ CESSNA       421C          2     8    90 Recipro~
##  3 N315AT     NA Fixed wing s~ JOHN G HESS  AT-5          1     2    NA 4 Cycle 
##  4 N347AA   1985 Rotorcraft    SIKORSKY     S-76A         2    14    NA Turbo-s~
##  5 N350AA   1980 Fixed wing m~ PIPER        PA-31-~       2     8   162 Recipro~
##  6 N364AA   1973 Fixed wing m~ CESSNA       310Q          2     6   167 Recipro~
##  7 N365AA   2001 Rotorcraft    AGUSTA SPA   A109E         2     8    NA Turbo-s~
##  8 N376AA   1978 Fixed wing s~ PIPER        PA-32R~       1     7    NA Recipro~
##  9 N377AA     NA Fixed wing s~ PAIR MIKE E  FALCON~       1     2    NA Recipro~
## 10 N378AA   1963 Fixed wing s~ CESSNA       172E          1     4   105 Recipro~
## # ... with 29 more rows
\end{verbatim}

Ve speciálních případech je užitečné vybírat řádky ne podle splnění určitých podmínek, ale podle jiných kritérií. Pro tyto případy je v balíku \emph{dplyr} obsažena funkce \texttt{slice()}. \emph{(Poznámka: zde diskutované funkce \texttt{slice()} získala s verzí dplyr mnoho nových úloh a rolí. V předchozích verzích umožňovala pouze výběr řádku na základě jeho čísla.)}

V základní variantě přijímá \texttt{slice()} číslo řádku, nebo jejich rozsah, který má být vybrán:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{slice}\NormalTok{(1L)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1 x 9
##   tailnum  year type            manufacturer model   engines seats speed engine 
##   <chr>   <int> <chr>           <chr>        <chr>     <int> <int> <int> <chr>  
## 1 N10156   2004 Fixed wing mul~ EMBRAER      EMB-14~       2    55    NA Turbo-~
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{slice}\NormalTok{(1L}\SpecialCharTok{:}\NormalTok{5L)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 9
##   tailnum  year type           manufacturer   model  engines seats speed engine 
##   <chr>   <int> <chr>          <chr>          <chr>    <int> <int> <int> <chr>  
## 1 N10156   2004 Fixed wing mu~ EMBRAER        EMB-1~       2    55    NA Turbo-~
## 2 N102UW   1998 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 3 N103US   1999 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 4 N104UW   1999 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 5 N10575   2002 Fixed wing mu~ EMBRAER        EMB-1~       2    55    NA Turbo-~
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{slice}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{2}\SpecialCharTok{:}\DecValTok{5}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 9
##   tailnum  year type           manufacturer   model  engines seats speed engine 
##   <chr>   <int> <chr>          <chr>          <chr>    <int> <int> <int> <chr>  
## 1 N10156   2004 Fixed wing mu~ EMBRAER        EMB-1~       2    55    NA Turbo-~
## 2 N102UW   1998 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 3 N103US   1999 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 4 N104UW   1999 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 5 N10575   2002 Fixed wing mu~ EMBRAER        EMB-1~       2    55    NA Turbo-~
\end{verbatim}

Poslední příklad ukazuje, že (a) číslo řádku nemusí být nutně zadáno jako integer (\texttt{L}) a (b) vstupem může být vektor vytvořený funkcí \texttt{c()}.

Speciální variantou \texttt{slice()} jsou varianty \texttt{slice\_head()}, \texttt{slice\_tail()}, \texttt{slice\_min()} a \texttt{slice\_max()}. Ty vrací \texttt{n} prvních/posledních řádků respektive \texttt{n} řádků s nejnižší/nejvyzšší hodnotou:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{slice\_head}\NormalTok{(}\AttributeTok{n =} \DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 9
##   tailnum  year type           manufacturer   model  engines seats speed engine 
##   <chr>   <int> <chr>          <chr>          <chr>    <int> <int> <int> <chr>  
## 1 N10156   2004 Fixed wing mu~ EMBRAER        EMB-1~       2    55    NA Turbo-~
## 2 N102UW   1998 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 3 N103US   1999 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 4 N104UW   1999 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 5 N10575   2002 Fixed wing mu~ EMBRAER        EMB-1~       2    55    NA Turbo-~
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{slice\_max}\NormalTok{(seats, }\AttributeTok{n =} \DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1 x 9
##   tailnum  year type             manufacturer model  engines seats speed engine 
##   <chr>   <int> <chr>            <chr>        <chr>    <int> <int> <int> <chr>  
## 1 N670US   1990 Fixed wing mult~ BOEING       747-4~       4   450    NA Turbo-~
\end{verbatim}

Počet řádků nemusí být určen jako absolutní číslo, ale je možné ho specifikovat v parametru \texttt{prop} jako podíl všech pozorování:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{slice\_head}\NormalTok{(}\AttributeTok{prop =} \FloatTok{0.001}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 9
##   tailnum  year type           manufacturer   model  engines seats speed engine 
##   <chr>   <int> <chr>          <chr>          <chr>    <int> <int> <int> <chr>  
## 1 N10156   2004 Fixed wing mu~ EMBRAER        EMB-1~       2    55    NA Turbo-~
## 2 N102UW   1998 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 3 N103US   1999 Fixed wing mu~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
\end{verbatim}

Toto volání vrátí 0,1 \% pozorování ze začátku tabulky.

Poslední speciální variantou \texttt{slice()} je \texttt{slice\_sample()}, která umožňuje provést náhodný výběr pozorování z tabulky. (V předchozích verzích \texttt{dplyr} k tomu sloužily funkce \texttt{sample\_*()}.) Počet řádků v náhodném výběru může být stanoveno opět absolutním číslem (parametr \texttt{n}) nebo podílem (parametr \texttt{prop}). Funkce umožňuje používat ve výběru váhy (parametr \texttt{weight\_by}) a zvolit výběr s nahrazením (parametr \texttt{replace}).

\hypertarget{vuxfdbux11br-sloupcux16f-promux11bnnuxfdch}{%
\subsection{Výběr sloupců (proměnných)}\label{vuxfdbux11br-sloupcux16f-promux11bnnuxfdch}}

Pro výběr sloupců slouží funkce \texttt{select()}. Syntax je podobná jako v případě \texttt{filter()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{select}\NormalTok{(.data, ...)}
\end{Highlighting}
\end{Shaded}

Do \texttt{select()} vstupuje tabulka a identifikace sloupců, které mají být vybrány. Například:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(tailnum, manufacturer)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 2
##    tailnum manufacturer    
##    <chr>   <chr>           
##  1 N10156  EMBRAER         
##  2 N102UW  AIRBUS INDUSTRIE
##  3 N103US  AIRBUS INDUSTRIE
##  4 N104UW  AIRBUS INDUSTRIE
##  5 N10575  EMBRAER         
##  6 N105UW  AIRBUS INDUSTRIE
##  7 N107US  AIRBUS INDUSTRIE
##  8 N108UW  AIRBUS INDUSTRIE
##  9 N109UW  AIRBUS INDUSTRIE
## 10 N110UW  AIRBUS INDUSTRIE
## # ... with 3,312 more rows
\end{verbatim}

Příklad ukazuje první a základní možnost, jak identifikovat sloupec -- a to jeho jménem. \texttt{select()} však umožňuje specifikovat sloupec i pomocí čísla pozice.

Následující volání funkce \texttt{select()} tak vrací stejný výsledek, jako tomu byl v případě identifikace sloupců jejich jménem.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{4}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 2
##    tailnum manufacturer    
##    <chr>   <chr>           
##  1 N10156  EMBRAER         
##  2 N102UW  AIRBUS INDUSTRIE
##  3 N103US  AIRBUS INDUSTRIE
##  4 N104UW  AIRBUS INDUSTRIE
##  5 N10575  EMBRAER         
##  6 N105UW  AIRBUS INDUSTRIE
##  7 N107US  AIRBUS INDUSTRIE
##  8 N108UW  AIRBUS INDUSTRIE
##  9 N109UW  AIRBUS INDUSTRIE
## 10 N110UW  AIRBUS INDUSTRIE
## # ... with 3,312 more rows
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%}\NormalTok{ names}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "tailnum"      "year"         "type"         "manufacturer" "model"       
## [6] "engines"      "seats"        "speed"        "engine"
\end{verbatim}

\hypertarget{funkce-select-a-speciuxe1lnuxed-funkce}{%
\subsubsection{\texorpdfstring{Funkce \texttt{select()} a speciální funkce}{Funkce select() a speciální funkce}}\label{funkce-select-a-speciuxe1lnuxed-funkce}}

Při identifikaci sloupců je možné využít speciální funkce. Některé fungují pouze ``uvnitř'' \texttt{select()} a některých dalších funkcí z \emph{tidyverse}.

První taková funkce je \texttt{:}. Umožňuje specifikovat rozsah sloupců, místo vypisování všech prvků. Všechny následující volání tak vrací stejný výsledek:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{2}\NormalTok{,}\DecValTok{3}\NormalTok{,}\DecValTok{4}\NormalTok{,}\DecValTok{8}\NormalTok{)}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(tailnum, year, type, manufacturer, speed)}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{4}\NormalTok{, }\DecValTok{8}\NormalTok{)}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(tailnum}\SpecialCharTok{:}\NormalTok{manufacturer, speed)}
\end{Highlighting}
\end{Shaded}

Další speciální funkcí je \texttt{-} (mínus). Tato funkce umožňuje ``negativní'' výběr. Při jejím použití není sloupec zahrnut, ale naopak vypuštěn:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\SpecialCharTok{{-}}\NormalTok{tailnum, }\SpecialCharTok{{-}}\NormalTok{year, }\SpecialCharTok{{-}}\NormalTok{type, }\SpecialCharTok{{-}}\NormalTok{manufacturer, }\SpecialCharTok{{-}}\NormalTok{speed)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 4
##    model     engines seats engine   
##    <chr>       <int> <int> <chr>    
##  1 EMB-145XR       2    55 Turbo-fan
##  2 A320-214        2   182 Turbo-fan
##  3 A320-214        2   182 Turbo-fan
##  4 A320-214        2   182 Turbo-fan
##  5 EMB-145LR       2    55 Turbo-fan
##  6 A320-214        2   182 Turbo-fan
##  7 A320-214        2   182 Turbo-fan
##  8 A320-214        2   182 Turbo-fan
##  9 A320-214        2   182 Turbo-fan
## 10 A320-214        2   182 Turbo-fan
## # ... with 3,312 more rows
\end{verbatim}

Speciální funkce je možné kombinovat -- je například možné vypustit sloupce identifikované rozsahem (\texttt{:}):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\SpecialCharTok{{-}}\NormalTok{tailnum}\SpecialCharTok{:{-}}\NormalTok{manufacturer, }\SpecialCharTok{{-}}\NormalTok{speed)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 4
##    model     engines seats engine   
##    <chr>       <int> <int> <chr>    
##  1 EMB-145XR       2    55 Turbo-fan
##  2 A320-214        2   182 Turbo-fan
##  3 A320-214        2   182 Turbo-fan
##  4 A320-214        2   182 Turbo-fan
##  5 EMB-145LR       2    55 Turbo-fan
##  6 A320-214        2   182 Turbo-fan
##  7 A320-214        2   182 Turbo-fan
##  8 A320-214        2   182 Turbo-fan
##  9 A320-214        2   182 Turbo-fan
## 10 A320-214        2   182 Turbo-fan
## # ... with 3,312 more rows
\end{verbatim}

Výsledné tabulky jsou pochopitelně shodné.

Obě tyto speciální funkce vyžadují přesnou specifikaci jména nebo pozice sloupce. V reálném životě občas pracujeme s poněkud vágnějším zadáním. Mohli bychom chtít například vybrat všechny sloupce, které obsahují informace o motorech. Ty jsou v tabulce \texttt{planes} dva \texttt{engine} (typ motoru) a \texttt{engines} (počet motorů).

První možností je samozřejmě možné použít následující volání a vybrat sloupce jejich výčtem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(engine,engines)}
\end{Highlighting}
\end{Shaded}

To však není praktické v případě, že pracujeme s větším množstvím sloupců, jejichž názvy jsou systematické. V tom případě je užitečné sáhnout po \emph{select helpers} (funkcích pomocníčcích chcete-li). \emph{dplyr} jich nabízí hned několik:

\begin{itemize}
\tightlist
\item
  \texttt{starts\_with()} vybírá sloupce, jejichž jméno začíná na řetězec, který je argumentem funkce \texttt{starts\_with()}
\item
  \texttt{ends\_with()} vybírá sloupce, jejichž jméno končí na řetězec, který je argumentem funkce \texttt{ends\_with()}
\item
  \texttt{contains()} vybírá sloupce, jejichž jméno obsahuje řetězec, který je argumentem funkce \texttt{contains()}
\item
  \texttt{matches()} vybírá sloupce, jejichž jméno odpovídá zadanému regulárnímu výrazu
\item
  \texttt{num\_range()} slouží pro výběr sloupců, jejichž jméno je tvořeno kombinací řetězce a čísla -- například \texttt{trial\_1}, \texttt{trial\_2},\ldots{}
\item
  \texttt{everything()} vrací všechny sloupce
\item
  \texttt{last\_col()} vrací poslední sloupec
\end{itemize}

Pro výběr proměnných se vztahem k motorům lze použít hned tři funkce:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\FunctionTok{starts\_with}\NormalTok{(}\StringTok{"engine"}\NormalTok{))}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\FunctionTok{contains}\NormalTok{(}\StringTok{"engine"}\NormalTok{))}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\FunctionTok{matches}\NormalTok{(}\StringTok{"\^{}engine"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

První a třetí varianta vybere všechny sloupce, které začínají na ``engine''. Druhé variantě postačí k výběru, že řetězec ``engine'' se vyskytuje kdekoliv ve jméně sloupce.

Další \emph{select helpers} umožňují vybrat sloupce podle jmen ze vstupního vektoru.

\begin{itemize}
\tightlist
\item
  \texttt{all\_of()} vrátí tabulku s vybranými sloupci pouze tehdy, pokud se ji podaří najít všechna jména obsažená ve vstupním vektoru. V opačném případě vrátí chybu.
\item
  \texttt{any\_of()} vrátí prostě jenom ty sloupce, které v tabulce najde.
\end{itemize}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\FunctionTok{all\_of}\NormalTok{(}\StringTok{"engine"}\NormalTok{)) }\CommentTok{\# Vrátí jeden sloupec}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\FunctionTok{all\_of}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"engine"}\NormalTok{,}\StringTok{"Engine"}\NormalTok{))) }\CommentTok{\# Vrátí chybu}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\FunctionTok{any\_of}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"engine"}\NormalTok{,}\StringTok{"Engine"}\NormalTok{))) }\CommentTok{\# Vrátí jeden sloupec}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(}\FunctionTok{any\_of}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"Engine"}\NormalTok{))) }\CommentTok{\# Nevrátí řádný sloupec.}
\end{Highlighting}
\end{Shaded}

\emph{Select helpers} mohou být kombinováni se všemi ostatními způsoby identifikace sloupců:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(tailnum, }\FunctionTok{starts\_with}\NormalTok{(}\StringTok{"engine"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 3
##    tailnum engines engine   
##    <chr>     <int> <chr>    
##  1 N10156        2 Turbo-fan
##  2 N102UW        2 Turbo-fan
##  3 N103US        2 Turbo-fan
##  4 N104UW        2 Turbo-fan
##  5 N10575        2 Turbo-fan
##  6 N105UW        2 Turbo-fan
##  7 N107US        2 Turbo-fan
##  8 N108UW        2 Turbo-fan
##  9 N109UW        2 Turbo-fan
## 10 N110UW        2 Turbo-fan
## # ... with 3,312 more rows
\end{verbatim}

Posledním \emph{select helper} je \texttt{where()}. Tato funkce umožňuje vybrat sloupce s pomocí funkce vracející logickou hdonotu. Je tak možné například vybrat pouze sloupce, které obahují celá čísla:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\FunctionTok{where}\NormalTok{(is.integer))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 4
##     year engines seats speed
##    <int>   <int> <int> <int>
##  1  2004       2    55    NA
##  2  1998       2   182    NA
##  3  1999       2   182    NA
##  4  1999       2   182    NA
##  5  2002       2    55    NA
##  6  1999       2   182    NA
##  7  1999       2   182    NA
##  8  1999       2   182    NA
##  9  1999       2   182    NA
## 10  1999       2   182    NA
## # ... with 3,312 more rows
\end{verbatim}

Všiměte si, že samotná funkce \texttt{is.integer} je parametrem \texttt{where()} a nikoliv její výstup. Je proto nutné do funkce zadat \texttt{is.integer} a nikoliv \texttt{is.integer()}.

Funkce \texttt{where()} je jedna z novinek v \emph{dplyr} 1.0.0 a společně s dalšími funkcemi nahradila tzv. scoped varianty základních funkcí (\texttt{select\_if()} atp.).

\emph{Select helper} s velmi specifickým využitím je \texttt{everything()}, které slouží k vybrání všeho. Nebo lépe všeho ostatního. Pokud z nějakého důvodu chceme změnit pořadí sloupců v tabulce, potom se hodí právě \texttt{everything()}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(engine, engines, }\FunctionTok{everything}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 9
##    engine   engines tailnum  year type          manufacturer  model  seats speed
##    <chr>      <int> <chr>   <int> <chr>         <chr>         <chr>  <int> <int>
##  1 Turbo-f~       2 N10156   2004 Fixed wing m~ EMBRAER       EMB-1~    55    NA
##  2 Turbo-f~       2 N102UW   1998 Fixed wing m~ AIRBUS INDUS~ A320-~   182    NA
##  3 Turbo-f~       2 N103US   1999 Fixed wing m~ AIRBUS INDUS~ A320-~   182    NA
##  4 Turbo-f~       2 N104UW   1999 Fixed wing m~ AIRBUS INDUS~ A320-~   182    NA
##  5 Turbo-f~       2 N10575   2002 Fixed wing m~ EMBRAER       EMB-1~    55    NA
##  6 Turbo-f~       2 N105UW   1999 Fixed wing m~ AIRBUS INDUS~ A320-~   182    NA
##  7 Turbo-f~       2 N107US   1999 Fixed wing m~ AIRBUS INDUS~ A320-~   182    NA
##  8 Turbo-f~       2 N108UW   1999 Fixed wing m~ AIRBUS INDUS~ A320-~   182    NA
##  9 Turbo-f~       2 N109UW   1999 Fixed wing m~ AIRBUS INDUS~ A320-~   182    NA
## 10 Turbo-f~       2 N110UW   1999 Fixed wing m~ AIRBUS INDUS~ A320-~   182    NA
## # ... with 3,312 more rows
\end{verbatim}

Změní pořadí sloupců tak, že na první pozici přesune \texttt{engine} a \texttt{engines} a následně do tabulky vyskládá všechny ostatní sloupce. Díky \texttt{everything()} není nutné jejich jména vypisovat. Do verze 1.0.0 bylo použití \texttt{select()} prakticky jedinou možností jak změnit pořadí sloupců. O dtéto verze v \emph{dplyr} existuje specializovaná funkce \texttt{relocate()}, která také umí pracovat se \emph{select helpers}.

\hypertarget{dalux161uxed-speciuxe1lnuxed-funkce}{%
\subsubsection{Další speciální funkce}\label{dalux161uxed-speciuxe1lnuxed-funkce}}

Při práci s výběry, které jsou v podstatě jen logickým vektorem nad jmény sloupců, je možné používat logické operátory \texttt{!} (negace), \texttt{\textbar{}} (OR) a \texttt{\&} (AND):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\SpecialCharTok{!}\FunctionTok{starts\_with}\NormalTok{(}\StringTok{"engi"}\NormalTok{)) }\CommentTok{\# Vrátí sloupce, které nezačínají na "engi"}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 7
##    tailnum  year type                    manufacturer     model     seats speed
##    <chr>   <int> <chr>                   <chr>            <chr>     <int> <int>
##  1 N10156   2004 Fixed wing multi engine EMBRAER          EMB-145XR    55    NA
##  2 N102UW   1998 Fixed wing multi engine AIRBUS INDUSTRIE A320-214    182    NA
##  3 N103US   1999 Fixed wing multi engine AIRBUS INDUSTRIE A320-214    182    NA
##  4 N104UW   1999 Fixed wing multi engine AIRBUS INDUSTRIE A320-214    182    NA
##  5 N10575   2002 Fixed wing multi engine EMBRAER          EMB-145LR    55    NA
##  6 N105UW   1999 Fixed wing multi engine AIRBUS INDUSTRIE A320-214    182    NA
##  7 N107US   1999 Fixed wing multi engine AIRBUS INDUSTRIE A320-214    182    NA
##  8 N108UW   1999 Fixed wing multi engine AIRBUS INDUSTRIE A320-214    182    NA
##  9 N109UW   1999 Fixed wing multi engine AIRBUS INDUSTRIE A320-214    182    NA
## 10 N110UW   1999 Fixed wing multi engine AIRBUS INDUSTRIE A320-214    182    NA
## # ... with 3,312 more rows
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\FunctionTok{starts\_with}\NormalTok{(}\StringTok{"e"}\NormalTok{) }\SpecialCharTok{\&} \FunctionTok{ends\_with}\NormalTok{(}\StringTok{"s"}\NormalTok{)) }\CommentTok{\# Vrátí sloupce začínající na "e" a zároveň končící na "s"}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 1
##    engines
##      <int>
##  1       2
##  2       2
##  3       2
##  4       2
##  5       2
##  6       2
##  7       2
##  8       2
##  9       2
## 10       2
## # ... with 3,312 more rows
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\FunctionTok{starts\_with}\NormalTok{(}\StringTok{"e"}\NormalTok{) }\SpecialCharTok{|} \FunctionTok{ends\_with}\NormalTok{(}\StringTok{"s"}\NormalTok{)) }\CommentTok{\# Vrátí sloupce začínající na "e" nebo končící na "s"}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 3
##    engines engine    seats
##      <int> <chr>     <int>
##  1       2 Turbo-fan    55
##  2       2 Turbo-fan   182
##  3       2 Turbo-fan   182
##  4       2 Turbo-fan   182
##  5       2 Turbo-fan    55
##  6       2 Turbo-fan   182
##  7       2 Turbo-fan   182
##  8       2 Turbo-fan   182
##  9       2 Turbo-fan   182
## 10       2 Turbo-fan   182
## # ... with 3,312 more rows
\end{verbatim}

Podobně je možné výběry kombinovat pomocí funkce \texttt{c()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\FunctionTok{starts\_with}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"e"}\NormalTok{,}\StringTok{"s"}\NormalTok{))) }\CommentTok{\# Vrátí sloupce začínající na "e" nebo na "s"}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 4
##    engines engine    seats speed
##      <int> <chr>     <int> <int>
##  1       2 Turbo-fan    55    NA
##  2       2 Turbo-fan   182    NA
##  3       2 Turbo-fan   182    NA
##  4       2 Turbo-fan   182    NA
##  5       2 Turbo-fan    55    NA
##  6       2 Turbo-fan   182    NA
##  7       2 Turbo-fan   182    NA
##  8       2 Turbo-fan   182    NA
##  9       2 Turbo-fan   182    NA
## 10       2 Turbo-fan   182    NA
## # ... with 3,312 more rows
\end{verbatim}

\hypertarget{vuxfdbux11br-a-pux159ejmenovuxe1nuxed-sloupce}{%
\subsubsection{Výběr a přejmenování sloupce}\label{vuxfdbux11br-a-pux159ejmenovuxe1nuxed-sloupce}}

Jednou ze speciálních funkcí je i \texttt{=}. To slouží v \texttt{select()} pro přejmenování. Například volání

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(tailnum, }\AttributeTok{company =}\NormalTok{ manufacturer)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 2
##    tailnum company         
##    <chr>   <chr>           
##  1 N10156  EMBRAER         
##  2 N102UW  AIRBUS INDUSTRIE
##  3 N103US  AIRBUS INDUSTRIE
##  4 N104UW  AIRBUS INDUSTRIE
##  5 N10575  EMBRAER         
##  6 N105UW  AIRBUS INDUSTRIE
##  7 N107US  AIRBUS INDUSTRIE
##  8 N108UW  AIRBUS INDUSTRIE
##  9 N109UW  AIRBUS INDUSTRIE
## 10 N110UW  AIRBUS INDUSTRIE
## # ... with 3,312 more rows
\end{verbatim}

vybere sloupce \texttt{tailnum} a \texttt{manufacturer}. Sloupec \texttt{manufacturer} však zároveň přejmenuje na \texttt{company}.

Speciálně pro přejmenovávání sloupců je v \emph{dplyr} obsažena funkce \texttt{rename()} (fakticky jde jen o lehkou mutaci \texttt{select()}). Ta sloupce nevybírá, ale jen přejmenovává. Použití \texttt{=} je v ní povinné:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{rename}\NormalTok{(tailnum, }\AttributeTok{company =}\NormalTok{ manufacturer)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: All renaming inputs must be named.
\end{verbatim}

Po opravě získáme správný výsledek:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{rename}\NormalTok{(}\AttributeTok{company =}\NormalTok{ manufacturer)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 9
##    tailnum  year type           company      model   engines seats speed engine 
##    <chr>   <int> <chr>          <chr>        <chr>     <int> <int> <int> <chr>  
##  1 N10156   2004 Fixed wing mu~ EMBRAER      EMB-14~       2    55    NA Turbo-~
##  2 N102UW   1998 Fixed wing mu~ AIRBUS INDU~ A320-2~       2   182    NA Turbo-~
##  3 N103US   1999 Fixed wing mu~ AIRBUS INDU~ A320-2~       2   182    NA Turbo-~
##  4 N104UW   1999 Fixed wing mu~ AIRBUS INDU~ A320-2~       2   182    NA Turbo-~
##  5 N10575   2002 Fixed wing mu~ EMBRAER      EMB-14~       2    55    NA Turbo-~
##  6 N105UW   1999 Fixed wing mu~ AIRBUS INDU~ A320-2~       2   182    NA Turbo-~
##  7 N107US   1999 Fixed wing mu~ AIRBUS INDU~ A320-2~       2   182    NA Turbo-~
##  8 N108UW   1999 Fixed wing mu~ AIRBUS INDU~ A320-2~       2   182    NA Turbo-~
##  9 N109UW   1999 Fixed wing mu~ AIRBUS INDU~ A320-2~       2   182    NA Turbo-~
## 10 N110UW   1999 Fixed wing mu~ AIRBUS INDU~ A320-2~       2   182    NA Turbo-~
## # ... with 3,312 more rows
\end{verbatim}

Tabulka obsahuje všechny sloupce, ale jeden z nich byl přejmenován.

\hypertarget{tvorba-a-uxfaprava-obsahu}{%
\section{Tvorba a úprava obsahu}\label{tvorba-a-uxfaprava-obsahu}}

Balík \emph{dplyr} obsahuje dvě základní funkce pro vytváření a agregaci obsahu v tabulkách: \texttt{mutate()} a \texttt{summarise()}

\hypertarget{tvorba-novuxfdch-sloupcux16f-s-mutate}{%
\subsection{\texorpdfstring{Tvorba nových sloupců s \texttt{mutate()}}{Tvorba nových sloupců s mutate()}}\label{tvorba-novuxfdch-sloupcux16f-s-mutate}}

Funkce \texttt{mutate()} vytváří nové sloupce, proměnné, v tabulce. Zachovává tedy počet řádků v tabulce a přidává nové sloupce. Syntax \texttt{mutate()} je podobně jako u dalších funkcí z \emph{tidyverse} poměrně střídmá:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{mutate}\NormalTok{(.data, ...)}
\end{Highlighting}
\end{Shaded}

Funkce přijímá vstupní tabulku a specifikaci sloupců, které se mají vytvořit v \texttt{...}. Fungování \texttt{mutate()} může být ilustrováno následujícím (mírně zjednodušujícím) schématem:

\begin{figure}
\centering
\includegraphics[width=0.5\textwidth,height=\textheight]{figs/dplyr/fig_mutate.png}
\caption{Tvorba nových sloupců s \texttt{mutate()}}
\end{figure}

\texttt{mutate()} může být použito i pro modifikaci stávajících sloupců. V tomto případě však \texttt{mutate()} interně nejprve vytvoří nový sloupec a až následně jím nahradí sloupec původní. Při modifikaci sloupce na opravdu velkých tabulkách tak může \texttt{mutate()} spotřebovávat nečekané množství systémových zdrojů.

Praktické využití \texttt{mutate()} je možné ilustrovat na příkladu. Například můžeme chtít pro každé pozorování (řádek, letadlo) v tabulce \texttt{planes} spočítat, kolik sedadel připadá na jeden motor a zjistit, zda se jedná o vrtulové letadlo:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{seats\_per\_engine =}\NormalTok{ (seats}\SpecialCharTok{/}\NormalTok{engines) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{round}\NormalTok{(),}
        \AttributeTok{turbo\_prop\_plane =}\NormalTok{ engine }\SpecialCharTok{==} \StringTok{"Turbo{-}prop"}
\NormalTok{    ) }\CommentTok{\#\%\textgreater{}\% }
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 11
##    tailnum  year type          manufacturer   model  engines seats speed engine 
##    <chr>   <int> <chr>         <chr>          <chr>    <int> <int> <int> <chr>  
##  1 N10156   2004 Fixed wing m~ EMBRAER        EMB-1~       2    55    NA Turbo-~
##  2 N102UW   1998 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  3 N103US   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  4 N104UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  5 N10575   2002 Fixed wing m~ EMBRAER        EMB-1~       2    55    NA Turbo-~
##  6 N105UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  7 N107US   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  8 N108UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  9 N109UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 10 N110UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## # ... with 3,312 more rows, and 2 more variables: seats_per_engine <dbl>,
## #   turbo_prop_plane <lgl>
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
    \CommentTok{\#select(seats\_per\_engine, turbo\_prop\_plane, everything())}
\end{Highlighting}
\end{Shaded}

\texttt{mutate()} vytvořilo dva nové sloupce. Sloupec \texttt{seats\_per\_engine} obsahuje zaokrouhlený počet sedadel na motor. Za povšimnutí stojí způsob, jakým byl jeho výpočet ve funkci \texttt{mutate()} specifikován. Na levé straně je jméno nově vytvářeného sloupce. Na pravé straně od ``='' je postup, který se má použít pro vytvoření jejího obsahu. Jména sloupců z tabulky se přitom používají jako proměnné. Příklad také ukazuje, že v \texttt{mutate()} je možné používat komplikované výrazy včetně trubek \texttt{\%\textgreater{}\%}.

V jednom volání \texttt{mutate()} je možné vytvořit více nových sloupců. Jednotlivé specifikace jsou ve volání odděleny čárkou. Druhý vytvořený sloupec ukazuje příklad vytvoření logické proměnné. Ohledně typu zpracovávaných nebo výsledných proměnných nemá \texttt{mutate()} žádné omezení.

\texttt{mutate()} přidává nově vytvořené sloupce na konec tabulky. Proto je v příkladu použita funkce \texttt{select()}, která je přesunuje na začátek tabulky. Verze 1.0.0 umožňuje nastavit, kde se v tabulce nové sloupce vytvoří, nicméně tato funkcionalita je stále ve fázi vývoje.

U popisu fungování \texttt{mutate()} je výše zmíněná možnost modifikace stávajících sloupců. V praxi se taková operace provede jednoduše. Předpokládejme, že chceme sloupec \texttt{year} nahradit jeho vlastním logaritmem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{year =} \FunctionTok{log}\NormalTok{(year)}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 9
##    tailnum  year type          manufacturer   model  engines seats speed engine 
##    <chr>   <dbl> <chr>         <chr>          <chr>    <int> <int> <int> <chr>  
##  1 N10156   7.60 Fixed wing m~ EMBRAER        EMB-1~       2    55    NA Turbo-~
##  2 N102UW   7.60 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  3 N103US   7.60 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  4 N104UW   7.60 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  5 N10575   7.60 Fixed wing m~ EMBRAER        EMB-1~       2    55    NA Turbo-~
##  6 N105UW   7.60 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  7 N107US   7.60 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  8 N108UW   7.60 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  9 N109UW   7.60 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 10 N110UW   7.60 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## # ... with 3,312 more rows
\end{verbatim}

Pokud jméno nového sloupce odpovídá některému sloupci, který již je v tabulce obsažen, je tento novým sloupcem nahrazen.

\texttt{mutate()} umí pracovat i s proměnnými, které nejsou součástí tabulky. V následujícím případě je nově vytvořený sloupec \texttt{this\_is\_true} naplněn konstantou přiřazenou do proměnné \texttt{x}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \ConstantTok{TRUE}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{this\_is\_true =}\NormalTok{ x}
\NormalTok{    ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(this\_is\_true, }\FunctionTok{everything}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 10
##    this_is_true tailnum  year type       manufacturer  model engines seats speed
##    <lgl>        <chr>   <int> <chr>      <chr>         <chr>   <int> <int> <int>
##  1 TRUE         N10156   2004 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  2 TRUE         N102UW   1998 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  3 TRUE         N103US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  4 TRUE         N104UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  5 TRUE         N10575   2002 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  6 TRUE         N105UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  7 TRUE         N107US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  8 TRUE         N108UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  9 TRUE         N109UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## 10 TRUE         N110UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## # ... with 3,312 more rows, and 1 more variable: engine <chr>
\end{verbatim}

Stejného výsledku by bylo dosaženo, kdyby byla konstanta definována přímo v \texttt{mutate()} tj. \texttt{this\_is\_true\ =\ TRUE}.

Na proměnnou, která takto do \texttt{mutate()} vstupuje zvnějšku je uvaleno omezení: musí mít délku jedna, nebo délku odpovídající počtu řádků tabulky. Tato podmínka není v následujícím příkladu splněna (vektor \texttt{x} má délku 3):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{, }\ConstantTok{TRUE}\NormalTok{)}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{this\_is\_true =}\NormalTok{ x}
\NormalTok{    ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(this\_is\_true, }\FunctionTok{everything}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: Problem with `mutate()` column `this_is_true`.
## i `this_is_true = x`.
## i `this_is_true` must be size 3322 or 1, not 3.
\end{verbatim}

Pokud má vektor \texttt{x} délku 1, potom je tato jedna hodnota přiřazena ke každému řádku. Pokud je délka \texttt{x} právě rovna počtu řádků, potom je ke každému řádku přiřazena hodnota na odpovídající pozici:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{x }\OtherTok{\textless{}{-}} \DecValTok{1}\SpecialCharTok{:}\FunctionTok{nrow}\NormalTok{(planes)}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{new\_variable =}\NormalTok{ x}
\NormalTok{    ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(new\_variable, }\FunctionTok{everything}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 10
##    new_variable tailnum  year type       manufacturer  model engines seats speed
##           <int> <chr>   <int> <chr>      <chr>         <chr>   <int> <int> <int>
##  1            1 N10156   2004 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  2            2 N102UW   1998 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  3            3 N103US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  4            4 N104UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  5            5 N10575   2002 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  6            6 N105UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  7            7 N107US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  8            8 N108UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  9            9 N109UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## 10           10 N110UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## # ... with 3,312 more rows, and 1 more variable: engine <chr>
\end{verbatim}

Naprosto stejná pravidla platí pro funkce. V příkladu je použita funkce \texttt{rnorm(n)}, která vrací \texttt{n} výběrů z normálního rozdělení. První dva příklady jsou vyhodnoceny bez problémů. Poslední je nekorektní a skončí chybou, protože \texttt{rnorm(3)} vrací vektor o délce 3.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{new\_variable =} \FunctionTok{rnorm}\NormalTok{(}\DecValTok{1}\NormalTok{)}
\NormalTok{    ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(new\_variable, }\FunctionTok{everything}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 10
##    new_variable tailnum  year type       manufacturer  model engines seats speed
##           <dbl> <chr>   <int> <chr>      <chr>         <chr>   <int> <int> <int>
##  1        -1.34 N10156   2004 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  2        -1.34 N102UW   1998 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  3        -1.34 N103US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  4        -1.34 N104UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  5        -1.34 N10575   2002 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  6        -1.34 N105UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  7        -1.34 N107US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  8        -1.34 N108UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  9        -1.34 N109UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## 10        -1.34 N110UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## # ... with 3,312 more rows, and 1 more variable: engine <chr>
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{new\_variable =} \FunctionTok{rnorm}\NormalTok{(}\FunctionTok{nrow}\NormalTok{(planes))}
\NormalTok{    ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(new\_variable, }\FunctionTok{everything}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 10
##    new_variable tailnum  year type       manufacturer  model engines seats speed
##           <dbl> <chr>   <int> <chr>      <chr>         <chr>   <int> <int> <int>
##  1        0.779 N10156   2004 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  2        0.791 N102UW   1998 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  3        1.21  N103US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  4        1.05  N104UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  5       -1.68  N10575   2002 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  6       -0.200 N105UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  7       -2.28  N107US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  8        1.02  N108UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  9       -0.893 N109UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## 10        0.388 N110UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## # ... with 3,312 more rows, and 1 more variable: engine <chr>
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{new\_variable =} \FunctionTok{rnorm}\NormalTok{(}\DecValTok{3}\NormalTok{)}
\NormalTok{    ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(new\_variable, }\FunctionTok{everything}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: Problem with `mutate()` column `new_variable`.
## i `new_variable = rnorm(3)`.
## i `new_variable` must be size 3322 or 1, not 3.
\end{verbatim}

\hypertarget{uxfaskaluxed-mutate}{%
\subsubsection{\texorpdfstring{Úskalí \texttt{mutate()}}{Úskalí mutate()}}\label{uxfaskaluxed-mutate}}

Výše byl použit příklad, ve kterém byla při stanovení hodnoty použita proměnná definovaná mimo tabulku. Při troše smůly se může stát, že jméno této proměnné se bude shodovat se jménem některého sloupce. V souladu s logikou R dostane přednost obsah sloupce:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{tailnum }\OtherTok{\textless{}{-}} \ConstantTok{TRUE}

\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{this\_is\_true =}\NormalTok{ tailnum}
\NormalTok{    ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(this\_is\_true, }\FunctionTok{everything}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 10
##    this_is_true tailnum  year type       manufacturer  model engines seats speed
##    <chr>        <chr>   <int> <chr>      <chr>         <chr>   <int> <int> <int>
##  1 N10156       N10156   2004 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  2 N102UW       N102UW   1998 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  3 N103US       N103US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  4 N104UW       N104UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  5 N10575       N10575   2002 Fixed win~ EMBRAER       EMB-~       2    55    NA
##  6 N105UW       N105UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  7 N107US       N107US   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  8 N108UW       N108UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
##  9 N109UW       N109UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## 10 N110UW       N110UW   1999 Fixed win~ AIRBUS INDUS~ A320~       2   182    NA
## # ... with 3,312 more rows, and 1 more variable: engine <chr>
\end{verbatim}

Další úskalí v použití spočívá v tom, že \texttt{mutate()} pracuje nad celou tabulkou a ne nad jednotlivými řádky. Toto chování lze změnit pomocí vhodného zgrupování, ale je potřeba ho mít na paměti. Co to znamená v praxi:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{mean\_year =} \FunctionTok{mean}\NormalTok{(year, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{)}
\NormalTok{    ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(mean\_year, }\FunctionTok{everything}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 10
##    mean_year tailnum  year type    manufacturer model engines seats speed engine
##        <dbl> <chr>   <int> <chr>   <chr>        <chr>   <int> <int> <int> <chr> 
##  1     2000. N10156   2004 Fixed ~ EMBRAER      EMB-~       2    55    NA Turbo~
##  2     2000. N102UW   1998 Fixed ~ AIRBUS INDU~ A320~       2   182    NA Turbo~
##  3     2000. N103US   1999 Fixed ~ AIRBUS INDU~ A320~       2   182    NA Turbo~
##  4     2000. N104UW   1999 Fixed ~ AIRBUS INDU~ A320~       2   182    NA Turbo~
##  5     2000. N10575   2002 Fixed ~ EMBRAER      EMB-~       2    55    NA Turbo~
##  6     2000. N105UW   1999 Fixed ~ AIRBUS INDU~ A320~       2   182    NA Turbo~
##  7     2000. N107US   1999 Fixed ~ AIRBUS INDU~ A320~       2   182    NA Turbo~
##  8     2000. N108UW   1999 Fixed ~ AIRBUS INDU~ A320~       2   182    NA Turbo~
##  9     2000. N109UW   1999 Fixed ~ AIRBUS INDU~ A320~       2   182    NA Turbo~
## 10     2000. N110UW   1999 Fixed ~ AIRBUS INDU~ A320~       2   182    NA Turbo~
## # ... with 3,312 more rows
\end{verbatim}

\texttt{mutate()} v tomto případě vypočítal průměrnou hodnotu ze všech roků a tu přiřadil ke všem sloupcům. Opět je to dáno tím, že \texttt{mean} neprodukuje vektor o délce odpovídající počtu řádků, ale vektor o délce 1.

\hypertarget{agregace-promux11bnnuxfdch-se-summarise}{%
\subsection{\texorpdfstring{Agregace proměnných se \texttt{summarise()}}{Agregace proměnných se summarise()}}\label{agregace-promux11bnnuxfdch-se-summarise}}

Podstatou agregace je shrnutí obsahu tabulky (jednoho nebo více sloupců) a vytvoření nové tabulky, která obsahuje tyto agregované hodnoty (typicky statistiky jako průměr, medián, minimum, atp.).

\begin{figure}
\centering
\includegraphics[width=0.5\textwidth,height=\textheight]{figs/dplyr/fig_summarise.png}
\caption{Agregace obsahu tabulky se \texttt{summarise()}}
\end{figure}

Pro tyto účely slouží v \emph{dplyr} funkce \texttt{summarise()}. Její použití se v logice velmi podobá \texttt{mutate()}. To ilustruje následující příklad:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{summarise}\NormalTok{(}
        \AttributeTok{min\_year =} \FunctionTok{min}\NormalTok{(year, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{),}
        \AttributeTok{max\_year =} \FunctionTok{max}\NormalTok{(year, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{),}
        \AttributeTok{min\_engines =} \FunctionTok{min}\NormalTok{(engines, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{),}
        \AttributeTok{max\_engines =} \FunctionTok{max}\NormalTok{(engines, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{)}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1 x 4
##   min_year max_year min_engines max_engines
##      <int>    <int>       <int>       <int>
## 1     1956     2013           1           4
\end{verbatim}

V tomto volání funkce \texttt{summarise()} jsou vytvořeny 4 agregované hodnoty: maxima a minima ze sloupců \texttt{year} a \texttt{engines}. Výsledkem je tabulka, která podle stanovených pravidel shrnuje celou tabulku do jediného řádku.

\hypertarget{dalux161uxed-uux17eiteux10dnuxe9-funkce-z-baluxedku-dplyr}{%
\section{\texorpdfstring{Další užitečné funkce z balíku \emph{dplyr}}{Další užitečné funkce z balíku dplyr}}\label{dalux161uxed-uux17eiteux10dnuxe9-funkce-z-baluxedku-dplyr}}

Balík \emph{dplyr} obsahuje opravdu velmi mnoho funkcí, které pracují nad jednou tabulkou. V této kapitole je představen lehký výběr těch, které se v praxi datové analýzy používají opravdu často.

Funkce \texttt{distinct()} je ekvivalentem \texttt{unique()} -- vrací tabulku, která obsahuje pouze unikátní pozorování. V případě shody více řádků zachovává v nové tabulce první z nich. Proti \texttt{unique()} je rychlejší a hlavně umožňuje specifikovat sloupce, podle kterých se má unikátnost pozorování posuzovat:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{distinct}\NormalTok{(manufacturer, type)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 37 x 2
##    type                     manufacturer        
##    <chr>                    <chr>               
##  1 Fixed wing multi engine  EMBRAER             
##  2 Fixed wing multi engine  AIRBUS INDUSTRIE    
##  3 Fixed wing multi engine  BOEING              
##  4 Fixed wing multi engine  AIRBUS              
##  5 Fixed wing multi engine  BOMBARDIER INC      
##  6 Fixed wing single engine CESSNA              
##  7 Fixed wing multi engine  CESSNA              
##  8 Fixed wing single engine JOHN G HESS         
##  9 Fixed wing multi engine  GULFSTREAM AEROSPACE
## 10 Rotorcraft               SIKORSKY            
## # ... with 27 more rows
\end{verbatim}

V základním nastavení je výstupní tabulka omezena pouze na proměnné, které byly použity k posouzení unikátnosti. Toto chování se dá změnit pomocí parametru \texttt{.keep\_all}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{distinct}\NormalTok{(manufacturer, type, }\AttributeTok{.keep\_all =} \ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 37 x 9
##    tailnum  year type        manufacturer    model  engines seats speed engine  
##    <chr>   <int> <chr>       <chr>           <chr>    <int> <int> <int> <chr>   
##  1 N10156   2004 Fixed wing~ EMBRAER         EMB-1~       2    55    NA Turbo-f~
##  2 N102UW   1998 Fixed wing~ AIRBUS INDUSTR~ A320-~       2   182    NA Turbo-f~
##  3 N11206   2000 Fixed wing~ BOEING          737-8~       2   149    NA Turbo-f~
##  4 N125UW   2009 Fixed wing~ AIRBUS          A320-~       2   182    NA Turbo-f~
##  5 N131EV   2009 Fixed wing~ BOMBARDIER INC  CL-60~       2    95    NA Turbo-f~
##  6 N201AA   1959 Fixed wing~ CESSNA          150          1     2    90 Recipro~
##  7 N202AA   1980 Fixed wing~ CESSNA          421C         2     8    90 Recipro~
##  8 N315AT     NA Fixed wing~ JOHN G HESS     AT-5         1     2    NA 4 Cycle 
##  9 N344AA   1992 Fixed wing~ GULFSTREAM AER~ G-IV         2    22    NA Turbo-f~
## 10 N347AA   1985 Rotorcraft  SIKORSKY        S-76A        2    14    NA Turbo-s~
## # ... with 27 more rows
\end{verbatim}

Užitečnou funkcí je řazení pozorování. To má v \emph{dplyr} na starosti funkce \texttt{arrange()}. \texttt{arrange()} přijímá jako parametry vstupní tabulku a jména sloupců, podle kterých má tabulku seřadit:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{arrange}\NormalTok{(manufacturer,engines)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 9
##    tailnum  year type           manufacturer model  engines seats speed engine  
##    <chr>   <int> <chr>          <chr>        <chr>    <int> <int> <int> <chr>   
##  1 N365AA   2001 Rotorcraft     AGUSTA SPA   A109E        2     8    NA Turbo-s~
##  2 N125UW   2009 Fixed wing mu~ AIRBUS       A320-~       2   182    NA Turbo-f~
##  3 N126UW   2009 Fixed wing mu~ AIRBUS       A320-~       2   182    NA Turbo-f~
##  4 N127UW   2010 Fixed wing mu~ AIRBUS       A320-~       2   182    NA Turbo-f~
##  5 N128UW   2010 Fixed wing mu~ AIRBUS       A320-~       2   182    NA Turbo-f~
##  6 N150UW   2013 Fixed wing mu~ AIRBUS       A321-~       2   199    NA Turbo-f~
##  7 N151UW   2013 Fixed wing mu~ AIRBUS       A321-~       2   199    NA Turbo-f~
##  8 N152UW   2013 Fixed wing mu~ AIRBUS       A321-~       2   199    NA Turbo-f~
##  9 N153UW   2013 Fixed wing mu~ AIRBUS       A321-~       2   199    NA Turbo-f~
## 10 N154UW   2013 Fixed wing mu~ AIRBUS       A321-~       2   199    NA Turbo-f~
## # ... with 3,312 more rows
\end{verbatim}

\texttt{arrange()} nejprve řadí tabulku podle první zadaného sloupce, následně podle druhého, atp. Směr řazení je možné změnit pomocí speciální funkce \texttt{desc()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{arrange}\NormalTok{(}\FunctionTok{desc}\NormalTok{(manufacturer),engines)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 9
##    tailnum  year type        manufacturer    model  engines seats speed engine  
##    <chr>   <int> <chr>       <chr>           <chr>    <int> <int> <int> <chr>   
##  1 N397AA   1985 Fixed wing~ STEWART MACO    FALCO~       1     2    NA Recipro~
##  2 N521AA     NA Fixed wing~ STEWART MACO    FALCO~       1     2    NA Recipro~
##  3 N347AA   1985 Rotorcraft  SIKORSKY        S-76A        2    14    NA Turbo-s~
##  4 N537JB   2012 Rotorcraft  ROBINSON HELIC~ R66          1     5    NA Turbo-s~
##  5 N376AA   1978 Fixed wing~ PIPER           PA-32~       1     7    NA Recipro~
##  6 N425AA   1968 Fixed wing~ PIPER           PA-28~       1     4   107 Recipro~
##  7 N545AA   1976 Fixed wing~ PIPER           PA-32~       1     7   126 Recipro~
##  8 N350AA   1980 Fixed wing~ PIPER           PA-31~       2     8   162 Recipro~
##  9 N525AA   1980 Fixed wing~ PIPER           PA-31~       2     8   162 Recipro~
## 10 N377AA     NA Fixed wing~ PAIR MIKE E     FALCO~       1     2    NA Recipro~
## # ... with 3,312 more rows
\end{verbatim}

\hypertarget{operace-nad-sloupci}{%
\section{Operace nad sloupci}\label{operace-nad-sloupci}}

Funkce z balíku \emph{dplyr} umožňují spouštět funkce nad specifikovanými sloupci tabulky. Prvním příkladem užití takové funkcionality může být výběr sloupců určitého datového typu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}\FunctionTok{where}\NormalTok{(is.character))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 5
##    tailnum type                    manufacturer     model     engine   
##    <chr>   <chr>                   <chr>            <chr>     <chr>    
##  1 N10156  Fixed wing multi engine EMBRAER          EMB-145XR Turbo-fan
##  2 N102UW  Fixed wing multi engine AIRBUS INDUSTRIE A320-214  Turbo-fan
##  3 N103US  Fixed wing multi engine AIRBUS INDUSTRIE A320-214  Turbo-fan
##  4 N104UW  Fixed wing multi engine AIRBUS INDUSTRIE A320-214  Turbo-fan
##  5 N10575  Fixed wing multi engine EMBRAER          EMB-145LR Turbo-fan
##  6 N105UW  Fixed wing multi engine AIRBUS INDUSTRIE A320-214  Turbo-fan
##  7 N107US  Fixed wing multi engine AIRBUS INDUSTRIE A320-214  Turbo-fan
##  8 N108UW  Fixed wing multi engine AIRBUS INDUSTRIE A320-214  Turbo-fan
##  9 N109UW  Fixed wing multi engine AIRBUS INDUSTRIE A320-214  Turbo-fan
## 10 N110UW  Fixed wing multi engine AIRBUS INDUSTRIE A320-214  Turbo-fan
## # ... with 3,312 more rows
\end{verbatim}

Výběr byl proveden s použitím dodatečné select-helper funce \texttt{where()}. Do té byl vložen výraz, který byl vyhodnocen nad sloupci tabulky. Výsledek, logický vektor, byl potom použit pro výběr funkcí \texttt{select()}.

Všiměte si, že funkce \texttt{is.character()} je v příkladu použita bez závorek. Parametrem \texttt{where()} je totiž funkce samotná a nikoliv její výstup.

\emph{dplyr} umožňuje uživateli provádět i sofistikovanější operace -- typicky modifikovat sloupce, které splňují určitou podmínku. Můžeme například chtít konvertovat číselné sloupce na \texttt{character}. Pro tyto účely slouží funkce \texttt{across()}. Ta má dva vstupy: (a) výraz, který identifikuje sloupce, které se mají modifikovat, a (b) výraz, který se má pro samotnou modifikaci použít. řešení by mohlo vypadat následujícím způsobem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{mutate}\NormalTok{(}
    \FunctionTok{across}\NormalTok{(}
      \FunctionTok{where}\NormalTok{(is.numeric),}
\NormalTok{      as.character}
\NormalTok{    )}
\NormalTok{  )}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 9
##    tailnum year  type          manufacturer   model  engines seats speed engine 
##    <chr>   <chr> <chr>         <chr>          <chr>  <chr>   <chr> <chr> <chr>  
##  1 N10156  2004  Fixed wing m~ EMBRAER        EMB-1~ 2       55    <NA>  Turbo-~
##  2 N102UW  1998  Fixed wing m~ AIRBUS INDUST~ A320-~ 2       182   <NA>  Turbo-~
##  3 N103US  1999  Fixed wing m~ AIRBUS INDUST~ A320-~ 2       182   <NA>  Turbo-~
##  4 N104UW  1999  Fixed wing m~ AIRBUS INDUST~ A320-~ 2       182   <NA>  Turbo-~
##  5 N10575  2002  Fixed wing m~ EMBRAER        EMB-1~ 2       55    <NA>  Turbo-~
##  6 N105UW  1999  Fixed wing m~ AIRBUS INDUST~ A320-~ 2       182   <NA>  Turbo-~
##  7 N107US  1999  Fixed wing m~ AIRBUS INDUST~ A320-~ 2       182   <NA>  Turbo-~
##  8 N108UW  1999  Fixed wing m~ AIRBUS INDUST~ A320-~ 2       182   <NA>  Turbo-~
##  9 N109UW  1999  Fixed wing m~ AIRBUS INDUST~ A320-~ 2       182   <NA>  Turbo-~
## 10 N110UW  1999  Fixed wing m~ AIRBUS INDUST~ A320-~ 2       182   <NA>  Turbo-~
## # ... with 3,312 more rows
\end{verbatim}

Funkce \texttt{across()} funguje výborně s funkcemi jako je \texttt{mutate()} nebo \texttt{summarise()}. V \emph{dplyr} 1.0.4 přibyly nové funkce, které jsou navženy tak, aby podobným způsobem umožnili pracovat s \texttt{filter()}. Jde o \texttt{if\_any()} a \texttt{if\_all()}. Jejich syntaxe a parametry jsou stejné jako u \texttt{across()}, ale na ro rozdíl od \texttt{across()} vracejí logický vektor, který je požadovaným vstupem funkce \texttt{filter()}.

Následující příklad ukazuje, jak řešit obyvklý problém v datové analýze -- někde nám utíkají pozorování, protože některé řádky v nějakém sloupci obsahují \texttt{NA}. Funkce \texttt{if\_any()} nám umožňuje takové řádky lehce najít:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{filter}\NormalTok{(}
    \FunctionTok{if\_any}\NormalTok{(}
      \FunctionTok{everything}\NormalTok{(), }\CommentTok{\# tj. hledej ve všech sloupcích}
\NormalTok{      is.na}
\NormalTok{      )}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,299 x 9
##    tailnum  year type          manufacturer   model  engines seats speed engine 
##    <chr>   <int> <chr>         <chr>          <chr>    <int> <int> <int> <chr>  
##  1 N10156   2004 Fixed wing m~ EMBRAER        EMB-1~       2    55    NA Turbo-~
##  2 N102UW   1998 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  3 N103US   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  4 N104UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  5 N10575   2002 Fixed wing m~ EMBRAER        EMB-1~       2    55    NA Turbo-~
##  6 N105UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  7 N107US   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  8 N108UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
##  9 N109UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## 10 N110UW   1999 Fixed wing m~ AIRBUS INDUST~ A320-~       2   182    NA Turbo-~
## # ... with 3,289 more rows
\end{verbatim}

Funkce \texttt{across()}, \texttt{where()}, \texttt{if\_any()} a \texttt{if\_all()} nahrazují tzv. scoped varianty základních funkcí ze starších verzí \emph{dplyr}.

\hypertarget{operace-nad-skupinami-ux159uxe1dkux16f}{%
\section{Operace nad skupinami řádků}\label{operace-nad-skupinami-ux159uxe1dkux16f}}

Všechny předchozí funkce lze s různou mírou elegance nahradit funkcemi ze základního R. Grupované operace však lze nahradit jen obtížně a v žádném případě ne elegantně. Podstatou zgrupované operace je vyhodnocení funkce nad jednotlivými segmenty tabulky. Na obrázku je zgrupovaná operace provedena funkce \texttt{summarise()}:

\begin{figure}
\centering
\includegraphics[width=0.5\textwidth,height=\textheight]{figs/dplyr/fig_group.png}
\caption{Zgrupované operace, příklad \texttt{summarise()}}
\end{figure}

\texttt{summarise()} je vykonáno nad jednotlivými barvenými grupami. Výsledky za jednotlivé grupy jsou následně složeny do nové tabulky.

V praktickém nasazení nás například může zajímat minimální, maximální a průměrný počet sedadel v letadlech jednotlivých výrobců.

V prvním kroku je potřeba pomocí funkce \texttt{group\_by()} vytvořit grupování -- tj. identifikovat řádky, které tvoří jednu grupu. Následně je možné volat funkci \texttt{summarise()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{group\_by}\NormalTok{(manufacturer) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{summarise}\NormalTok{(}
        \AttributeTok{min\_seats  =} \FunctionTok{min}\NormalTok{(seats, }\AttributeTok{na.rm  =} \ConstantTok{TRUE}\NormalTok{),}
        \AttributeTok{mean\_seats =} \FunctionTok{mean}\NormalTok{(seats, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{),}
        \AttributeTok{max\_seats  =} \FunctionTok{max}\NormalTok{(seats, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{)}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 35 x 4
##    manufacturer           min_seats mean_seats max_seats
##    <chr>                      <int>      <dbl>     <int>
##  1 AGUSTA SPA                     8        8           8
##  2 AIRBUS                       100      221.        379
##  3 AIRBUS INDUSTRIE             145      187.        379
##  4 AMERICAN AIRCRAFT INC          2        2           2
##  5 AVIAT AIRCRAFT INC             2        2           2
##  6 AVIONS MARCEL DASSAULT        12       12          12
##  7 BARKER JACK L                  2        2           2
##  8 BEECH                          9        9.5        10
##  9 BELL                           5        8          11
## 10 BOEING                       100      175.        450
## # ... with 25 more rows
\end{verbatim}

Protože nás zajímají počty sedadel v letadlech \emph{``jednotlivých výrobců''} je pro zgrupování použita proměnná \texttt{manufacturer}. \texttt{group\_by} však umí vytvořit i grupy tvořené kombinací více proměnných. Například by bylo možné zjistit počty sedadel pro skupinu vymezenou výrobcem a typem letounu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{group\_by}\NormalTok{(manufacturer, type) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{summarise}\NormalTok{(}
        \AttributeTok{min\_seats  =} \FunctionTok{min}\NormalTok{(seats, }\AttributeTok{na.rm  =} \ConstantTok{TRUE}\NormalTok{),}
        \AttributeTok{mean\_seats =} \FunctionTok{mean}\NormalTok{(seats, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{),}
        \AttributeTok{max\_seats  =} \FunctionTok{max}\NormalTok{(seats, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{)}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## `summarise()` has grouped output by 'manufacturer'. You can override using the `.groups` argument.
\end{verbatim}

\begin{verbatim}
## # A tibble: 37 x 5
## # Groups:   manufacturer [35]
##    manufacturer           type                    min_seats mean_seats max_seats
##    <chr>                  <chr>                       <int>      <dbl>     <int>
##  1 AGUSTA SPA             Rotorcraft                      8        8           8
##  2 AIRBUS                 Fixed wing multi engine       100      221.        379
##  3 AIRBUS INDUSTRIE       Fixed wing multi engine       145      187.        379
##  4 AMERICAN AIRCRAFT INC  Fixed wing single engi~         2        2           2
##  5 AVIAT AIRCRAFT INC     Fixed wing single engi~         2        2           2
##  6 AVIONS MARCEL DASSAULT Fixed wing multi engine        12       12          12
##  7 BARKER JACK L          Fixed wing single engi~         2        2           2
##  8 BEECH                  Fixed wing multi engine         9        9.5        10
##  9 BELL                   Rotorcraft                      5        8          11
## 10 BOEING                 Fixed wing multi engine       100      175.        450
## # ... with 27 more rows
\end{verbatim}

V \texttt{group\_by()} je možné použít proměnné všech typů (jakkoliv u \emph{double} to asi příliš často nedává smysl).

Grupované operace pochopitelně nejsou omezeny pouze na \texttt{summarise()}. Následující příklad ukazuje použití s \texttt{mutate()}. Jako cvičení můžete kód analyzovat a zjistit, co dělá.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{group\_by}\NormalTok{(manufacturer) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{year\_diff =}\NormalTok{ year }\SpecialCharTok{{-}} \FunctionTok{mean}\NormalTok{(year, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{)}
\NormalTok{    ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{select}\NormalTok{(tailnum, manufacturer, year, year\_diff) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{arrange}\NormalTok{(manufacturer, year)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3,322 x 4
## # Groups:   manufacturer [35]
##    tailnum manufacturer  year year_diff
##    <chr>   <chr>        <int>     <dbl>
##  1 N365AA  AGUSTA SPA    2001      0   
##  2 N186US  AIRBUS        2002     -5.20
##  3 N187US  AIRBUS        2002     -5.20
##  4 N188US  AIRBUS        2002     -5.20
##  5 N338NB  AIRBUS        2002     -5.20
##  6 N339NB  AIRBUS        2002     -5.20
##  7 N340NB  AIRBUS        2002     -5.20
##  8 N341NB  AIRBUS        2002     -5.20
##  9 N342NB  AIRBUS        2002     -5.20
## 10 N343NB  AIRBUS        2002     -5.20
## # ... with 3,312 more rows
\end{verbatim}

V prvním kroku kód přidá zgrupování k tabulce planes. Výsledek této operace můžeme vidět pomocí funkce \texttt{class()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{group\_by}\NormalTok{(manufacturer) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{class}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "grouped_df" "tbl_df"     "tbl"        "data.frame"
\end{verbatim}

Třída tabulky \texttt{planes} byla rozšířena o \texttt{grouped\_df}. To umožní kompatibilním metodám nakládat s tabulkou speciálním způsobem: provést operaci zgrupovaně. Pokud pro danou funkci není ``zgrupovaná'' metoda dostupná, provede se funkce jako obvykle nad celou tabulkou:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{group\_by}\NormalTok{(manufacturer) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{summary}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##    tailnum               year          type           manufacturer      
##  Length:3322        Min.   :1956   Length:3322        Length:3322       
##  Class :character   1st Qu.:1997   Class :character   Class :character  
##  Mode  :character   Median :2001   Mode  :character   Mode  :character  
##                     Mean   :2000                                        
##                     3rd Qu.:2005                                        
##                     Max.   :2013                                        
##                     NA's   :70                                          
##     model              engines          seats           speed      
##  Length:3322        Min.   :1.000   Min.   :  2.0   Min.   : 90.0  
##  Class :character   1st Qu.:2.000   1st Qu.:140.0   1st Qu.:107.5  
##  Mode  :character   Median :2.000   Median :149.0   Median :162.0  
##                     Mean   :1.995   Mean   :154.3   Mean   :236.8  
##                     3rd Qu.:2.000   3rd Qu.:182.0   3rd Qu.:432.0  
##                     Max.   :4.000   Max.   :450.0   Max.   :432.0  
##                                                     NA's   :3299   
##     engine         
##  Length:3322       
##  Class :character  
##  Mode  :character  
##                    
##                    
##                    
## 
\end{verbatim}

Třída \texttt{grouped\_df()} zůstává u tabulky zachována, dokud není jinou funkcí odstraněna. \emph{dplyr} umožňuje grupování odstranit funkcí \texttt{ungroup()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{planes }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{group\_by}\NormalTok{(manufacturer) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ungroup}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{class}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "tbl_df"     "tbl"        "data.frame"
\end{verbatim}

Částečnou výjimkou z tohoto pravidla je funkce \texttt{summarise()}, která získala parametr \texttt{.groups}, který umožňuje nastavit, jak má být nastaveno grupování u výstupní tabulky.

V dalším kroku příkladu je volána funkce \texttt{mutate()}. Ta zvlášť pro každou grupu vypočítá průměrný rok výroby (\texttt{mean(year,\ na.rm\ =\ TRUE)}) a tuto hodnotu (vektor o délce 1) odečte od všech hodnot v proměnné \texttt{year}. Výsledkem je tak vektor o délce identické s počtem řádků v grupě. Tento vektor je přidán jako sloupec \texttt{year\_diff}. Tabulka je následně zpřehledněna voláním \texttt{select()} a \texttt{mutate()}.

\hypertarget{bezpeux10dnuxe9-grupovuxe1nuxed}{%
\subsection{Bezpečné grupování}\label{bezpeux10dnuxe9-grupovuxe1nuxed}}

Zgrupované operace představují mimořádně mocný nástroj, který zásadně zjednodušuje a zpřehledňuje datovou analýzu. Mají však svá rizika a to zejména mezi židlí a klávesnicí. Pokud uživatel zapomene, že ve skutečnosti pracuje se zgrupovanou tabulkou může dostat bez varování zásadně odlišné výsledky. Proto je rozumné tabulku ``na konci trubky'' odgrupovat.

Potenciální riziko si uvědomují i tvůrci \emph{dplyr}. Například od verze 1.0.0 vrací \texttt{summarise()} po operaci nad zgrupovanou tabulkou varování. Od této verze je také možné také parametrem funkce nastavit, zda a jak má \texttt{summarise()} grupování zachovat. (V případě nastavení tohoto parametru už žádné varování nevrací.)

\hypertarget{slovesa-pracujuxedcuxed-se-dvux11bma-nebo-vuxedce-tabulkami}{%
\section{Slovesa pracující se dvěma (nebo více) tabulkami}\label{slovesa-pracujuxedcuxed-se-dvux11bma-nebo-vuxedce-tabulkami}}

Data bývají často dostupná ve více tabulkách, které mohou například mohou pocházet z různých zdrojů: HDP ze Světové banky, migrace z Eurostatu, atp. Pro účely datové analýzy je nutné takové tabulky spojovat do jednoho celku.

\emph{dplyr} podporuje dva druhy spojovacích operací:

\begin{itemize}
\tightlist
\item
  \emph{bind} spojuje tabulky, které mají stejnou strukturu -- v podstatě přidává sloupce (\texttt{bind\_cols()}) nebo řádky (\texttt{bind\_rows()})
\item
  \emph{join} slučuje tabulky podle určitého definovaného klíče -- například sloučí k sobě údaje o jednom člověku z více tabulek, které mohou mít naprosto odlišnou strukturu (více funkcí \texttt{*\_join()})
\end{itemize}

\hypertarget{spojovuxe1nuxed-tabulek-s-bind_}{%
\subsection{\texorpdfstring{Spojování tabulek s \texttt{bind\_*()}}{Spojování tabulek s bind\_*()}}\label{spojovuxe1nuxed-tabulek-s-bind_}}

Funkcí \texttt{bind\_rows()} a \texttt{bind\_cols()} je spojovat tabulky se stejnou strukturou. V případě, že jsou pozorování se stejnými proměnnými rozděleny do více tabulek, je potřeba tabulky poskládat ``pod sebe''. Jinými slovy přidávat další a další řádky s dodatečnými pozorováními. V tomto případě se hodí použít funkci \texttt{bind\_rows(...)}. Ta jako argument přijímá jména (neomezeného počtu) tabulek a nebo seznam (list) tabulek. Fungování \texttt{bind\_rows()} můžeme demonstrovat na tabulce \texttt{dplyr::band\_members}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{band\_members}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 2
##   name  band   
##   <chr> <chr>  
## 1 Mick  Stones 
## 2 John  Beatles
## 3 Paul  Beatles
\end{verbatim}

Do \texttt{bind\_rows()} můžeme vložit více tabulek:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{bind\_rows}\NormalTok{(band\_members, band\_members, band\_members)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 9 x 2
##   name  band   
##   <chr> <chr>  
## 1 Mick  Stones 
## 2 John  Beatles
## 3 Paul  Beatles
## 4 Mick  Stones 
## 5 John  Beatles
## 6 Paul  Beatles
## 7 Mick  Stones 
## 8 John  Beatles
## 9 Paul  Beatles
\end{verbatim}

\ldots nebo list tabulek:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{bind\_rows}\NormalTok{(}
    \FunctionTok{list}\NormalTok{(band\_members, band\_members, band\_members)}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 9 x 2
##   name  band   
##   <chr> <chr>  
## 1 Mick  Stones 
## 2 John  Beatles
## 3 Paul  Beatles
## 4 Mick  Stones 
## 5 John  Beatles
## 6 Paul  Beatles
## 7 Mick  Stones 
## 8 John  Beatles
## 9 Paul  Beatles
\end{verbatim}

Výsledky jsou pochopitelně stejné. Schopnost spojit tabulky uložené v seznamu je zvláště užitečná v případě, že pracujeme například s~výstupem funkce \texttt{map()} z~balíku \textbf{purrr}.

Předchozí příklady byly bezproblémové, protože tabulky měly stejnou strukturu -- tedy stejně pojmenované sloupce se stejnými datovými typy. Co se stane v případě volání \texttt{bind\_rows()} na nekonzistentní tabulky ukazuje následující příklad:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{band\_members }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{rename}\NormalTok{(}\AttributeTok{NAME =}\NormalTok{ name) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{bind\_rows}\NormalTok{(., band\_members)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 3
##   NAME  band    name 
##   <chr> <chr>   <chr>
## 1 Mick  Stones  <NA> 
## 2 John  Beatles <NA> 
## 3 Paul  Beatles <NA> 
## 4 <NA>  Stones  Mick 
## 5 <NA>  Beatles John 
## 6 <NA>  Beatles Paul
\end{verbatim}

\texttt{bind\_rows()} pod sebe složil hodnoty ze sloupců stejného jména. Sloupce s neshodujícími se jmény zachoval, ale do tabulky doplnil \texttt{NA}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{band\_members }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{rename}\NormalTok{(}\AttributeTok{NAME =}\NormalTok{ name) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{bind\_rows}\NormalTok{(., band\_members)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 3
##   NAME  band    name 
##   <chr> <chr>   <chr>
## 1 Mick  Stones  <NA> 
## 2 John  Beatles <NA> 
## 3 Paul  Beatles <NA> 
## 4 <NA>  Stones  Mick 
## 5 <NA>  Beatles John 
## 6 <NA>  Beatles Paul
\end{verbatim}

V případě nekonzistentních datových typů je situace zajímavější. V následujícím příkladu je sloupec name konvertován z \emph{character} na \emph{factor} a následně je tabulka spojena s nezměněnou tabulkou \texttt{band\_members}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{band\_members }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{name =} \FunctionTok{as.factor}\NormalTok{(name)}
\NormalTok{        ) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{bind\_rows}\NormalTok{(., band\_members)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 2
##   name  band   
##   <chr> <chr>  
## 1 Mick  Stones 
## 2 John  Beatles
## 3 Paul  Beatles
## 4 Mick  Stones 
## 5 John  Beatles
## 6 Paul  Beatles
\end{verbatim}

R umí provést automatickou konverzi faktorů na znaky. Provede ji, ale vypíše i upovídané varování. Výsledek je nicméně perfektně použitelný a ve většině případů bude odpovídat přání uživatele.

Větší problém nastane, pokud se ve spojovaných tabulkách vyskytnou sloupce stejného jména a rozdílných datových typů, u kterých R neumí provést automatickou konverzi. V tomto případě jde o \emph{double} a \emph{character}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{band\_members }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{name =}\NormalTok{ rnorm1)}
        \ErrorTok{)} \SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{bind\_rows}\NormalTok{(., band\_members)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: <text>:4:9: unexpected ')'
## 3:         name = rnorm1)
## 4:         )
##            ^
\end{verbatim}

Tato operace se neprovede a R vrátí chybu.

Podobně jako \texttt{bind\_rows()} funguje funkce \texttt{bind\_cols()}. Tabulky ovšem neskládá ``pod sebe''``, ale''vedle sebe". Předpokladem jejího použití je opět shodná struktura tabulek. To v tomto případě znamená zejména to, že jedno pozorování je vždy na stejném řádku. Pozorování je tak vlastně identifikováno číslem řádku. Syntaxe je stejná jako u \texttt{bind\_rows()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{bind\_cols}\NormalTok{(band\_members, band\_members, band\_members)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## New names:
## * name -> name...1
## * band -> band...2
## * name -> name...3
## * band -> band...4
## * name -> name...5
## * ...
\end{verbatim}

\begin{verbatim}
## # A tibble: 3 x 6
##   name...1 band...2 name...3 band...4 name...5 band...6
##   <chr>    <chr>    <chr>    <chr>    <chr>    <chr>   
## 1 Mick     Stones   Mick     Stones   Mick     Stones  
## 2 John     Beatles  John     Beatles  John     Beatles 
## 3 Paul     Beatles  Paul     Beatles  Paul     Beatles
\end{verbatim}

Za povšimnutí stojí, že pokud jsou ve spojovaných tabulkách shodná jména sloupců, \texttt{bind\_cols()} je do výsledné tabulky přidá všechny. Aby se však zabránilo nepřípustné duplicitě ve jménech sloupců, rozšíří duplicitní jména o příponu.

Z logiky věci nejsou problém odlišné datové typy ve spojovaných tabulkách, ale problém můžou představovat tabulky s různým počtem řádků:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{band\_members }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{sample\_n}\NormalTok{(}\DecValTok{2}\NormalTok{) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{bind\_cols}\NormalTok{(band\_members,.)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: Can't recycle `..1` (size 3) to match `..2` (size 2).
\end{verbatim}

Protože u \texttt{bind\_cols()} jsou pozorování fakticky identifikována číslem řádku, tak není možné takovou operaci smysluplně provést. \texttt{bind\_cols()} v takovém případě nic nehádá, nic nepředpokládá ani nerecykluje, ale poctivě vyvěsí bílou vlajku a vrátí chybu.

\hypertarget{sluux10dovuxe1nuxed-tabulek-s-_join}{%
\subsection{\texorpdfstring{Slučování tabulek s \texttt{*\_join()}}{Slučování tabulek s *\_join()}}\label{sluux10dovuxe1nuxed-tabulek-s-_join}}

\hypertarget{mutating-joins}{%
\subsubsection{Mutating joins}\label{mutating-joins}}

Slučování tabulek lze provádět pomocí různých slučovacích funkcí. Ty jsou v \emph{dplyr} jednotně pojmenovány tak, že končí řetězcem *\_join\emph{. Jejich základní skupina -- tzv. }mutating joins*, tj. slučovací funkce, které přidávají sloupce, se v zásadě chová jako ``inteligentní'' varianta \texttt{bind\_cols()}. Pozorování však není definováno číslem řádku, ale proměnnou nebo kombinací více proměnných.

Pro ilustraci slučování jsou potřeba dvě tabulky. Vedle \texttt{band\_members} využijeme \texttt{dplyr::band\_instruments}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{band\_instruments}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 2
##   name  plays 
##   <chr> <chr> 
## 1 John  guitar
## 2 Paul  bass  
## 3 Keith guitar
\end{verbatim}

Pravděpodobně nejčastěji používanou slučovací funkcí je \texttt{left\_join()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{left\_join}\NormalTok{(x, y, }\AttributeTok{by =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{copy =} \ConstantTok{FALSE}\NormalTok{, }\AttributeTok{suffix =} \FunctionTok{c}\NormalTok{(}\StringTok{".x"}\NormalTok{, }\StringTok{".y"}\NormalTok{), ...)}
\end{Highlighting}
\end{Shaded}

Jako argument přijímá právě dvě tabulky \texttt{x} a \texttt{y}. Slučovací funkce v \emph{dplyr} obecně umí pracovat pouze se dvěma tabulkami. Toto omezení je však možné obejít -- viz dále.

Dalším důležitým parametrem je \texttt{by} jeho hodnota určuje, podle kterých sloupců se má provést slučování -- tedy které sloupce definují pozorování. V případě, že je hodnota parametru \texttt{NULL}, potom se sloučení provede na základě všech sloupců, jejich jméno je v obou tabulkách. V tomto případě vrátí \emph{dplyr} informaci o tom, které sloupce použil.

Příklad použití \texttt{left\_join()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{left\_join}\NormalTok{(band\_members, band\_instruments)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Joining, by = "name"
\end{verbatim}

\begin{verbatim}
## # A tibble: 3 x 3
##   name  band    plays 
##   <chr> <chr>   <chr> 
## 1 Mick  Stones  <NA>  
## 2 John  Beatles guitar
## 3 Paul  Beatles bass
\end{verbatim}

\texttt{left\_join()} funguje tak, že vrací všechny řádky z \texttt{x} a všechny sloupce z tabulky \texttt{x} i \texttt{y}. Řádky z \texttt{x}, pro které neexistuje shoda v tabulce \texttt{y} mají v připojených sloupcích \texttt{NA}.

V tomto příkladu nebyl vyplněn parametr \texttt{by}. \texttt{left\_join()} tedy jako klíč pro slučování použil sloupec \texttt{name}, který se jako jediný vyskytoval v obou slučovaných tabulkách. Volání

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{left\_join}\NormalTok{(band\_members, band\_instruments, }\AttributeTok{by =} \StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 3
##   name  band    plays 
##   <chr> <chr>   <chr> 
## 1 Mick  Stones  <NA>  
## 2 John  Beatles guitar
## 3 Paul  Beatles bass
\end{verbatim}

by pochopitelně vedlo ke stejným výsledkům.

V případě slučování tabulek, ve kterých se vyskytují shodná jména sloupců, která ovšem neidentifikují pozorování je nutné parametr \texttt{by} specifikovat. Sloučení tabulek se stejnými názvy sloupců by jinak dopadlo například takto:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{left\_join}\NormalTok{(band\_members, band\_members)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Joining, by = c("name", "band")
\end{verbatim}

\begin{verbatim}
## # A tibble: 3 x 2
##   name  band   
##   <chr> <chr>  
## 1 Mick  Stones 
## 2 John  Beatles
## 3 Paul  Beatles
\end{verbatim}

Výsledkem by byla vstupní tabulka \texttt{x}. Pří specifikování identifikačního sloupce (například \texttt{name}) bude výsledek odlišný:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{left\_join}\NormalTok{(band\_members, band\_members, }\AttributeTok{by =} \StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 3
##   name  band.x  band.y 
##   <chr> <chr>   <chr>  
## 1 Mick  Stones  Stones 
## 2 John  Beatles Beatles
## 3 Paul  Beatles Beatles
\end{verbatim}

Slučované tabulky v tomto případě obsahují sloupec se shodným jménem, který není použit ke slučování. V tom případě je tento sloupec (podobně jako u \texttt{bind\_cols()}) přejmenován připojením přípony. Podobu přípony je možné specifikovat parametrem \texttt{suffix}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{left\_join}\NormalTok{(band\_members, band\_members, }\AttributeTok{by =} \StringTok{"name"}\NormalTok{, }\AttributeTok{suffix =} \FunctionTok{c}\NormalTok{(}\StringTok{".prvni"}\NormalTok{,}\StringTok{".druhy"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 3
##   name  band.prvni band.druhy
##   <chr> <chr>      <chr>     
## 1 Mick  Stones     Stones    
## 2 John  Beatles    Beatles   
## 3 Paul  Beatles    Beatles
\end{verbatim}

V předchozích příkladech byl parametr \texttt{by} použit pouze pro specifikaci jednoho sloupce, jehož jméno bylo přítomno v obou slučovaných tabulkách. Možností nastavení je však více:

\begin{itemize}
\tightlist
\item
  \texttt{by} může obsahovat jména více sloupců zadaných jako nepojmenovaný vektor, například \texttt{by\ =\ c("name","band")}
\item
  \texttt{by} může obsahovat i pojmenovaný vektor. Ten má ale zvláštní interpretaci. Jméno každého prvku odpovídá v takovém případě jménu sloupce z tabulky \texttt{x} a hodnota jménu sloupce z tabulky \texttt{y}. To umožňuje slučování tabulek, i když tyto neobsahují ani jeden sloupec se shodným jménem. Praktickou ukázkou je následující příklad, který využívá tabulku \texttt{dplyr::band\_instruments2}:
\end{itemize}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{band\_instruments2}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 2
##   artist plays 
##   <chr>  <chr> 
## 1 John   guitar
## 2 Paul   bass  
## 3 Keith  guitar
\end{verbatim}

Cílem je sloučit tabulky \texttt{band\_members} a \texttt{band\_instruments2} podle jména hudebníka. Tato proměnná se však jmenuje \texttt{name} v \texttt{band\_members} a \texttt{artist} v \texttt{band\_instruments2}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{left\_join}\NormalTok{(band\_members, band\_instruments2, }\AttributeTok{by =} \FunctionTok{c}\NormalTok{(}\StringTok{"name"} \OtherTok{=} \StringTok{"artist"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 3
##   name  band    plays 
##   <chr> <chr>   <chr> 
## 1 Mick  Stones  <NA>  
## 2 John  Beatles guitar
## 3 Paul  Beatles bass
\end{verbatim}

Používání slučovacích funkcí však má svoje úskalí. Představme si situaci, kdy identifikace pozorování není jednoznačná -- tedy situaci, kdy identifikátor pozorování odpovídá více řádkům. Vytvoříme tabulku \texttt{band\_instruments3}, která bude právě tuto podmínku splňovat:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{band\_instruments3 }\OtherTok{\textless{}{-}} \FunctionTok{bind\_rows}\NormalTok{(band\_instruments, band\_instruments)}

\FunctionTok{print}\NormalTok{(band\_instruments3)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 6 x 2
##   name  plays 
##   <chr> <chr> 
## 1 John  guitar
## 2 Paul  bass  
## 3 Keith guitar
## 4 John  guitar
## 5 Paul  bass  
## 6 Keith guitar
\end{verbatim}

Identifikátor -- jméno hudebníka -- teď není unikátní. Přináleží mu právě dva řádky. Následně tuto novou tabulku sloučíme s \texttt{band\_members}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{left\_join}\NormalTok{(band\_members, band\_instruments3, }\AttributeTok{by =} \StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 3
##   name  band    plays 
##   <chr> <chr>   <chr> 
## 1 Mick  Stones  <NA>  
## 2 John  Beatles guitar
## 3 John  Beatles guitar
## 4 Paul  Beatles bass  
## 5 Paul  Beatles bass
\end{verbatim}

Zde je patrné, že výsledek může být problematický. Výsledná tabulka má větší počet řádků, než vstupní tabulka \texttt{x} -- řádky, pro které bylo v tabulce \texttt{y} více záznamů se namnožily. \emph{dplyr} tuto operaci provedl \textbf{bez jakéhokoliv varování. Je proto kritické kontrolovat v průběhu sestavování datasetu konzistenci dat.} Jinak se lehko může stát, že výsledná tabulka a analýza na ni postavená bude bezcenná.

\texttt{left\_join()} není jediný \emph{mutating join} implementovaný v \emph{dplyr}, další jsou následující:

\begin{itemize}
\tightlist
\item
  \texttt{right\_join()} je bratr \texttt{left\_join()}. Vrací sloupce z \texttt{x} i \texttt{y}, ale řádky z \texttt{y}.
\item
  \texttt{inner\_join()} vrací sloupce z \texttt{x} i \texttt{y}, ale pouze řádky, která jsou jak v \texttt{x}, tak v \texttt{y}.
\item
  \texttt{full\_join()} vrací všechny sloupce a všechny řádky z \texttt{x} a \texttt{y}.
\end{itemize}

\hypertarget{filtering-joins}{%
\subsubsection{Filtering joins}\label{filtering-joins}}

Druhou skupinou slučovacích funkcí jsou tzv. \emph{filtering joins}. Tyto funkce opět pracují nad dvěma tabulkami \texttt{x} a \texttt{y}, ale vždy vrací sloupce pouze z tabulky \texttt{x}.

První takovou funkcí je \texttt{semi\_join()}, který vrací pouze ty řádky, které existují v obou tabulkách \texttt{x} i \texttt{y}. Je to vlastně blízký příbuzný \texttt{inner\_join()}.

Pro ilustraci fungování \emph{filtering joins} můžeme porovnat výsledky těchto funkcí:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{inner\_join}\NormalTok{(band\_members, band\_instruments, }\AttributeTok{by =} \StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 2 x 3
##   name  band    plays 
##   <chr> <chr>   <chr> 
## 1 John  Beatles guitar
## 2 Paul  Beatles bass
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{semi\_join}\NormalTok{(band\_members, band\_instruments, }\AttributeTok{by =} \StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 2 x 2
##   name  band   
##   <chr> <chr>  
## 1 John  Beatles
## 2 Paul  Beatles
\end{verbatim}

\texttt{inner\_join()} vrací sloupce z obou tabulek -- skutečně ``slučuje''. \texttt{semi\_join()} vrací sloupce pouze z první tabulky -- spíše tedy filtruje na základě informací z druhé tabulky.

Druhou funkcí z této skupiny slučovacích funkcí je \texttt{anti\_join()}, která je svým způsobem inverzní k \texttt{semi\_join()}. Vrací řádky z \texttt{x}, které nejsou obsaženy v \texttt{y}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{anti\_join}\NormalTok{(band\_members, band\_instruments, }\AttributeTok{by =} \StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1 x 2
##   name  band  
##   <chr> <chr> 
## 1 Mick  Stones
\end{verbatim}

\hypertarget{sluux10dovuxe1nuxed-vuxedce-tabulek}{%
\subsubsection{Slučování více tabulek}\label{sluux10dovuxe1nuxed-vuxedce-tabulek}}

Všechny funkce \texttt{*\_join()} pracují s dvěma tabulkami. V drtivé většině případů je to zcela postačující, nicméně najdou se i výjimky. V takovém případě je možné využit funkci \texttt{reduce()} z balíku \emph{purrr} (součást \emph{tidyverse}).

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{reduce}\NormalTok{(.x, .f, ..., .init)}
\end{Highlighting}
\end{Shaded}

Funkce má dva základní argumenty:

-\texttt{.x}\ldots je seznam (\emph{list}) nebo atomický vektor
-\texttt{.f}\ldots je funkce přijímající 2 vstupy
-\texttt{...}\ldots dodatečné argumenty pro funkci \texttt{.f}

\texttt{reduce()} funguje tak, že provádí ``akumulaci''. Nejprve aplikuje funkci \texttt{.f} na první dva prvky \texttt{.x}. V druhé iteraci aplikuje \texttt{.f} na výstup první iterace a na třetí prvek \texttt{.x} a tak dále.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{list}\NormalTok{(band\_members, band\_members, band\_members, band\_instruments) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{reduce}\NormalTok{(., left\_join, }\AttributeTok{by =} \StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 5
##   name  band.x  band.y  band    plays 
##   <chr> <chr>   <chr>   <chr>   <chr> 
## 1 Mick  Stones  Stones  Stones  <NA>  
## 2 John  Beatles Beatles Beatles guitar
## 3 Paul  Beatles Beatles Beatles bass
\end{verbatim}

Za pozornost stojí varianty jména sloupce \texttt{band}, které přesně odpovídají mechanismu fungování \texttt{reduce()}. V první iteraci nastal konflikt jmen sloupců. Obě slučované tabulky obsahovaly sloupec pojmenovaný \texttt{band} a proto ve výsledné tabulce dostaly příponu. V druhé iteraci již ke konfliktu nedošlo. Stará tabulka totiž obsahovala jména \texttt{band.x} a \texttt{band.y} a nová \texttt{band}. Sloupec z nové tabulky tak byl připojen bez změny jména.

Příklad by mohl pokračovat:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{list}\NormalTok{(band\_members, band\_members, band\_members, band\_members) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{reduce}\NormalTok{(., left\_join, }\AttributeTok{by =} \StringTok{"name"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 3 x 5
##   name  band.x  band.y  band.x.x band.y.y
##   <chr> <chr>   <chr>   <chr>    <chr>   
## 1 Mick  Stones  Stones  Stones   Stones  
## 2 John  Beatles Beatles Beatles  Beatles 
## 3 Paul  Beatles Beatles Beatles  Beatles
\end{verbatim}

\hypertarget{part-vizualizace-dat}{%
\part{Vizualizace dat}\label{part-vizualizace-dat}}

\hypertarget{kap:ggplot2}{%
\chapter{Vizualizace dat s balíkem ggplot2}\label{kap:ggplot2}}

V R existuje celá řada nástrojů pro vizualizaci dat, které jsou opravdu velmi heterogenní. Z úvodních lekcí znáte příklady tzv. \texttt{base} grafiky, která přichází s každou instalací R. Příklad může být Vám známá funkce \texttt{plot()}. Tato základní implementace nástrojů pro vizualizaci dat sleduje podobnou logiku jako je obvyklá v ostatních systémech: uživatel explicitně sděluje systému co a jak má vykreslit: ``Na souřadnice {[}X,Y{]} nakresli zelený křížek''.

Součástí \emph{tidyverse} je balík \emph{ggplot2}, který přistupuje k vizualizaci zcela jiným způsobem -- a to na mnoha úrovních. \emph{ggplot2} je založen na teorii \emph{``grammar of graphics''} (Wilkinson 2005, 2010) a pracuje na mnohem vyšší úrovni abstrakce. Uživatel vlastně předává funkci jako vstup popis dat a konkrétní provedení vizualizace nechává na ni. Tento způsob práce je poměrně neobvyklý, ale po jeho zvládnutí už neexistuje cesta zpět.

\emph{ggplot2} má jedno základní omezení -- kreslí pouze 2D obrázky. Na konci kapitoly však uvidíte, že nic jiného pravděpodobně ani nepotřebujete.

Co se v této lekci naučíte?

\begin{itemize}
\tightlist
\item
  základní logiku fungování \emph{ggplot2}
\item
  základní logiku ovládání \emph{ggplot2}
\item
  provést jednoduché vizualizace dat a modifikovat jejich vzhled
\end{itemize}

Složitější úkoly přijdou později.

Let's lock and load\ldots{}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(tidyverse)}
\end{Highlighting}
\end{Shaded}

\hypertarget{poznuxe1mka-3}{%
\subsubsection{Poznámka}\label{poznuxe1mka-3}}

\emph{ggplot2} je tak populární, že existují i jeho porty pro jiné jazyky -- například pro Python. I v samotném světě R existuje balík, který s \emph{ggplot2} sdílí nejen filosofii, ale i tvůrce. Balík \emph{ggvis} obsahuje oproti \emph{ggplot2} některá koncepční vylepšení. Celkově je však orientován spíše na interaktivní grafiku a proto pro naše účely není tak vhodný. Nicméně kdo pochopí \emph{ggplot2} zvládne lehce i \emph{ggvis}.

Výhodou popularity \emph{ggplot2} je i obrovské množství balíků, které možnosti \emph{ggplot2} doplňují nebo rozšiřují. Pokud tedy něco neumí samotný \emph{ggplot2} je rozumné porozhlédnout se po balících, které hledanou funkcionalitu doplňují. Neúplnou galerii ``rozšíření''" můžete najít například zde: \url{http://www.ggplot2-exts.org/gallery/}

\hypertarget{poznuxe1mka-2-1}{%
\paragraph{Poznámka 2}\label{poznuxe1mka-2-1}}

POdobně jako ostatní součásti \emph{tidyverse} se i \emph{ggplot2} dramaticky vyvíjí. Tento materiál byl například původně vytvořen s verzí 2.x. Nyní (září 2019) je aktuální verze 3.2.1. Nové verze přinesly zásadní změny, které se však v drtivě většině odehrály ``pod povrchem'' a pro uživatele nejsou patrné.

Velkou změnou pro uživatele je uvedení \texttt{geom\_sf()}, který radikálním způsobem zjednodušuje kreslení map.

\hypertarget{logika-fungovuxe1nuxed-ggplot2}{%
\section{\texorpdfstring{Logika fungování \emph{ggplot2}}{Logika fungování ggplot2}}\label{logika-fungovuxe1nuxed-ggplot2}}

Pro vysvětlení fungování \emph{ggplot2} použijeme schématický obrázek:

\begin{figure}
\centering
\includegraphics[width=0.6\textwidth,height=\textheight]{figs/ggplot2/all_mod.png}
\caption{Schéma obrázku vytvořeného v \emph{ggplot2}}
\end{figure}

\emph{ggplot2} je postaven na teorii \emph{layered grammar of graphics}, každý obrázek vytvořený za jeho pomoci se skládá z několika prvků:

\hypertarget{od-dat-k-vizualizaci}{%
\subsubsection{Od dat k vizualizaci}\label{od-dat-k-vizualizaci}}

Vizualizace dat, která se skládá z jedné, nebo mnoha překrývajících se vrstev (\emph{layers}). Každá vrstva přidává do výsledného obrázku jednu dodatečnou vizualizaci. Schématický obrázek má dvě vrstvy obsahující vizualizaci dat. První vrstva (bodový graf) obsahuje zobrazení surových dat -- tedy dat, jak jsou. Druhá vrstva vykresluje statistickou transformaci surových dat -- proloženou křivku. Obrázek je tedy konstruován podobně, jako byste přes sebe překládaly průsvitné fólie pokreslené fixem. Výsledný obrázek by se postupně rozšiřoval o další a další prvky. Nicméně prvky přidané později překrývají prvky přidané dříve.

Jako příklad vizualizace dat můžeme zkonstruovat následující bodový graf, který obsahuje dvě pozorování:

\begin{verbatim}
## Warning: `data_frame()` was deprecated in tibble 1.1.0.
## Please use `tibble()` instead.
\end{verbatim}

\begin{figure}
\centering
\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-3-1.pdf}
\caption{\label{fig:unnamed-chunk-3}Vizualizace dat s \emph{ggplot2}}
\end{figure}

Z tohoto obrázku vidíme, že pozorování jsou dvě a že nejsou identická. Nic dalšího říci nemůžeme.

\hypertarget{zpux11bt-od-vizualizace-k-datux16fm}{%
\subsubsection{Zpět od vizualizace k datům}\label{zpux11bt-od-vizualizace-k-datux16fm}}

Aby byl obrázek srozumitelný, musí být k vizualizaci dat připojeny prvky, které ji umožňují porozumět. Tedy umožňují uživateli převést vizualizaci zpět do dat. Takové prvky jsou škály, legendy, osy, atp. Viz obrázek:

\begin{figure}
\centering
\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-4-1.pdf}
\caption{\label{fig:unnamed-chunk-4}Prvky umožňující převod vizualizace zpět do dat}
\end{figure}

\hypertarget{vzhled-obruxe1zku}{%
\subsubsection{Vzhled obrázku}\label{vzhled-obruxe1zku}}

Poslední skupina prvků upravuje celkový vzhled obrázku. Nemá žádný vztah ke dvěma předchozím kategoriím. Tyto prvky upravují pouze celkový vzhled obrázku (velikost písma, barvu pozadí,\ldots).

Následující příklad ukazuje možný vzhled obrázku:

\begin{figure}
\centering
\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-5-1.pdf}
\caption{\label{fig:unnamed-chunk-5}Změny vzhledu obrázků}
\end{figure}

V \emph{ggplot2} se všechny tři skupiny prvků ovládají nezávisle na sobě. Pro vytvoření každého prvku existují speciální funkce.

\hypertarget{zuxe1kladnuxed-vizualizace-vrstva-po-vrstvux11b}{%
\section{Základní vizualizace: vrstva po vrstvě}\label{zuxe1kladnuxed-vizualizace-vrstva-po-vrstvux11b}}

Celkovou konstrukci obrázku můžeme ilustrovat na tabulce \texttt{diamonds}, která je součástí balíku \texttt{ggplot2}. Tabulka obsahuje informace o jednotlivých kamenech (viz \texttt{?diamonds}). Tabulka obsahuje přes 50 tisíc pozorování. Jejich vykreslování by zejména na pomalejších počítačích trvalo velmi dlouho. Proto budeme pracovat pouze s 500 náhodně vybranými řádky:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\OtherTok{\textless{}{-}}\NormalTok{ diamonds }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{sample\_n}\NormalTok{(}\DecValTok{500}\NormalTok{)}
\FunctionTok{print}\NormalTok{(diamonds)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 500 x 10
##    carat cut     color clarity depth table price     x     y     z
##    <dbl> <ord>   <ord> <ord>   <dbl> <dbl> <int> <dbl> <dbl> <dbl>
##  1  1.01 Good    J     VS1      61.5    61  4189  6.39  6.45  3.95
##  2  1.7  Ideal   I     SI1      62.4    56 11228  7.68  7.64  4.78
##  3  0.51 Ideal   G     VVS1     61.6    56  1933  5.12  5.16  3.17
##  4  0.73 Premium E     VS2      62.5    61  2862  5.78  5.64  3.59
##  5  1.07 Ideal   J     VS2      61.7    58  4686  6.58  6.55  4.05
##  6  0.31 Premium F     IF       61.5    58   979  4.33  4.35  2.67
##  7  1    Fair    F     SI1      65.8    58  4657  6.23  6.15  4.07
##  8  0.5  Fair    E     SI1      65.1    58  1114  5.04  4.94  3.25
##  9  0.35 Ideal   E     VS2      62      56   704  4.49  4.51  2.79
## 10  0.34 Ideal   D     VS2      61.3    57   805  4.47  4.5   2.75
## # ... with 490 more rows
\end{verbatim}

Našim cílem je vytvořit podobný obrázek, který byl použit pro schématickou ilustraci fungování \emph{ggplot2}: Vykreslit závislost ceny (\texttt{price}), váhy (\texttt{carat}) a kvality řezu (\texttt{cut}).

Základ každého obrázku vytvoříme pomocí funkce \texttt{ggplot()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{ggplot}\NormalTok{(}\AttributeTok{data =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{mapping =} \FunctionTok{aes}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

Funkce má dva základní argumenty: \texttt{data} obsahují tabulku s daty, která se mají vizualizovat. Parametr \texttt{mapping} pak přijímá základní pravidla, podle kterých se má vizualizace řídit. Přesněji řečeno pravidla vytvořená funkcí \texttt{aes()}, která určují, jaká proměnná se má \emph{mapovat} na kterou \emph{estetiku}.

Pro pochopení těchto pojmů je užitečné zamyslet se nad tím, jak vlastně funguje bodový graf. Jeho podstatou je to, že jedno pozorování, je reprezentováno jedním bodem. Jaké vlastnosti (estetiky) však tento bod může mít?

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Pozici v rovině obrázku: souřadnice na ose x (\texttt{x}) a y (\texttt{y})
\item
  Tvar (\texttt{shape}): kolečko, čtvereček, srdíčko, listy, káry,\ldots{}
\item
  Velikost (\texttt{size})
\item
  Barvu (\texttt{color}/\texttt{colour})
\item
  Barvu výplně (\texttt{fill})
\item
  Typ ohraničující linky (\texttt{stroke})
\item
  Průhlednost (\texttt{alpha})
\end{enumerate}

Všechny estetiky je možné nastavit (\emph{set}) nebo namapovat (\emph{map}). V případě nastavení bude estetika u všech pozorování stejná. V případě namapování se hodnota estetiky bude řídit podle hodnoty přiřazené proměnné.

Pokud tedy chceme vykreslit bodový graf závislosti, ceny a váhy, potom tyto proměnné chceme namapovat na vybrané estetiky. Stejného výsledku jako u úvodního obrázku dosáhneme pomocí \texttt{aes(x\ =\ carat,\ y\ =\ price)}. Základní volání \texttt{ggplot()} tedy může vypadat následovně:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price)}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-8-1.pdf}

Výsledkem je prázdná formátované plocha. Volání \texttt{ggplot()} totiž pouze vytvoří prázdné ``plátno'', na které je potřeba přidávat jednotlivé vrstvy s obsahem.

Nové vrstvy se typicky přidávají voláním funkcí \texttt{geom\_*()}. Tyto funkce nejsou nic jiného, než aliasy pro různé nastavení funkce \texttt{layer()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{layer}\NormalTok{(}\AttributeTok{geom =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{stat =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{data =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{mapping =} \ConstantTok{NULL}\NormalTok{,}
  \AttributeTok{position =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{params =} \FunctionTok{list}\NormalTok{(), }\AttributeTok{inherit.aes =} \ConstantTok{TRUE}\NormalTok{,}
  \AttributeTok{check.aes =} \ConstantTok{TRUE}\NormalTok{, }\AttributeTok{check.param =} \ConstantTok{TRUE}\NormalTok{, }\AttributeTok{subset =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{show.legend =} \ConstantTok{NA}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Funkce \texttt{layer()} má mnoho parametrů. Zásadní jsou tyto:

\begin{itemize}
\tightlist
\item
  \texttt{data}\ldots tabulka s daty, která se má použít v dané vrstvě. Pokud tento parametr není zadán, potom se použije tabulka dat specifikované ve volání \texttt{ggpplot()}. Každá vrstva tak může pracovat s jinými daty. (A také \texttt{ggplot()} nemusí obsahovat specifikaci dat.)
\item
  \texttt{geom}\ldots typ geometrického objektu, který se má použít pro vizualizaci dat. Může se jednat o bod (\texttt{point}), polygon (\texttt{polygon}), úsečku (\texttt{line}) a mnoho dalších.
\item
  \texttt{mapping}\ldots obsahuje namapování proměnných na estetiky pomocí funkce \texttt{aes()}. Pokud není parametr specifikován, potom se použije specifikace z \texttt{ggplot()}. Pokud je specifikace v konfliktu se specifikací v \texttt{ggplot()}, potom se použije specifikace z \texttt{layer()}. Pokud je specifikována estetika, která není přiřazena v \texttt{ggplot()}, potom se použije jako doplnění ke specifikaci z \texttt{ggplot()}.
\item
  \texttt{stat}\ldots statistická transformace dat, která se má provést před vykreslením. Vykreslují se až transformované data.
\item
  \texttt{position}\ldots umožňuje upravit pozici hrubých dat před jejich vykreslením
\end{itemize}

Funkce \texttt{layer()} není zpravidla nikdy volána přímo. V podstatě vždy se používají funkce \texttt{geom\_*()}. Pokud například chceme přidat vrstvu s bodovým grafem, potom použijeme \texttt{geom\_point()}. Tato funkce je přesným ekvivalentem volání:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{layer}\NormalTok{(}
  \AttributeTok{data =} \ConstantTok{NULL}\NormalTok{,}
  \AttributeTok{mapping =} \ConstantTok{NULL}\NormalTok{,}
  \AttributeTok{geom =} \StringTok{"point"}\NormalTok{,}
  \AttributeTok{stat =} \StringTok{"identity"}\NormalTok{,}
  \AttributeTok{position =} \StringTok{"identity"}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Pokračujme v příkladu konstrukcí bodového grafu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-11-1.pdf}

Vrstvu obsahující body jsme vytvořili voláním funkce \texttt{geom\_point()}. Tato nová vrstva je k původnímu volání \texttt{ggplot()} připojena funkcí \texttt{+}. Pomocí této funkce můžeme do obrázku přidávat další vrstvy -- například vrstvu, která vykreslí proloženou křivku:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{geom\_smooth}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## `geom_smooth()` using method = 'loess' and formula 'y ~ x'
\end{verbatim}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-12-1.pdf}

Jak vlastně funguje \texttt{ggplot2} vevnitř? Základní volání \texttt{ggplot()} vytvoří ``prázdnou'' datovou strukturu. Funkce \texttt{+} potom R říká, že má tuto datovou strukturu modifikovat. Jakým způsobem se to má stát určuje funkce volaná za \texttt{+}. Například \texttt{+\ geom\_point()} přidá k původní datové struktuře vrstvu s body, atd.

Primárním výsledkem volání \texttt{ggplot()} je tedy datová struktura. Tu můžeme přiřadit do proměnné:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\OtherTok{\textless{}{-}}\NormalTok{ diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\ldots a dále modifikovat\ldots{}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\OtherTok{\textless{}{-}}\NormalTok{ p }\SpecialCharTok{+} \FunctionTok{geom\_smooth}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\ldots nebo ``vytisknout'':

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## `geom_smooth()` using method = 'loess' and formula 'y ~ x'
\end{verbatim}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-15-1.pdf}

\hypertarget{mapovuxe1nuxed-a-nastavovuxe1nuxed-estetik}{%
\section{Mapování a nastavování estetik}\label{mapovuxe1nuxed-a-nastavovuxe1nuxed-estetik}}

V předchozím textu byl vysvětlen pojem estetika a mapování. Nyní se tomuto tématu budeme věnovat podrobněji. Každý \texttt{geom} má několik estetik -- dimenzí, jejichž podobu lze řídit podle určité proměnné. V případě bodového grafu (\texttt{point}) jde o: \texttt{x}, \texttt{y}, \texttt{shape}, \texttt{size}, \texttt{color}/\texttt{colour}, \texttt{fill}, \texttt{stroke} a \texttt{alpha}. Například \texttt{geom} \texttt{line} (spojnicový graf) má estetiky jiné -- nerozumí \texttt{stroke}, \texttt{shape} a \texttt{fill}. Namísto toho umí pracovat s \texttt{linetype}.

Výše uvedený příklad demonstruje mechanismus mapování. S pomocí funkce \texttt{aes()} je estetikám přiřazena proměnná. Některé estetiky je v závislosti na geomu nutné přiřadit. V případě \texttt{geom\_point()} je to například \texttt{x} a \texttt{y}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error: geom_point requires the following missing aesthetics: y
\end{verbatim}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-16-1.pdf}

Pomocí \texttt{aes()} je možné mapovat i další estetiky:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price, }\AttributeTok{size =}\NormalTok{ x, }\AttributeTok{color =}\NormalTok{ cut)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-17-1.pdf}

Pro každou namapovanou estetiku \texttt{ggplot2} vytvoří vodítko, které čtenáři umožní překlad z vizualizace do dat. V případě \texttt{x} a \texttt{y} vykreslí osy grafu. U zbývajících estetik vykreslil legendu.

Jednu proměnnou jde mapovat i na více estetik:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price, }\AttributeTok{size =}\NormalTok{ cut, }\AttributeTok{color =}\NormalTok{ cut)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-18-1.pdf}

\texttt{ggplot2} takovou kombinaci zohlední i v legendě. Tento příklad ukazuje i další vlastnost \texttt{ggplot2}. Pokud uživatel požaduje provedení něčeho, co Tvůrce (H. Wickham) nepovažuje za dobrý nápad, vrátí \texttt{ggplot2} upozornění (via \texttt{message()}).

\texttt{ggplot2} poskytuje obrovské množství možností a částečně uživateli radí. Nicméně je na uživateli, aby vše nastavil tak, aby výsledné obrázky splňovaly svůj účel -- jasně čtenáři předávaly určitou informaci. Obrázek použitý v příkladu například trpí zásadní vadou, která se říká ``overplotting''. Pozorování se vzájemně překrývají a ve výsledný obrázek čtenáři mnoho neřekne. Nemůže vědět, zda se v některém místě vzájemně překrývá málo, nebo mnoho pozorování. Jednoduchou a často dostačující cestou jak bojovat s tímto problémem je nastavení průhlednosti (estetiky \texttt{alpha}). Tuto estetiku lze samozřejmě mapovat na proměnnou, ale v tomto případě ji použijeme pro ilustraci nastavení estetiky:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{(}\AttributeTok{alpha =} \FloatTok{0.1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-19-1.pdf}

Pokud chce uživatel estetiku nastavit, je potřeba ji deklarovat v příslušné \texttt{geom\_*()} funkci a mimo funkci \texttt{aes()}. Příklad ukazuje, že nastavení průhlednosti problém s overplottingem minimálně zmírnilo.

\hypertarget{kontrola-mapovuxe1nuxed}{%
\subsection{Kontrola mapování}\label{kontrola-mapovuxe1nuxed}}

Ve všech příkladech jsme dosud pouze mapovali estetiku na určité proměnné. Mapování předává \texttt{ggplot2} informaci typu: ``barvu puntíků urči podle proměnné \texttt{cut}''. Jak konkrétně to \texttt{ggplot2} provede (t.j. bude mít špatný řez červenou, modrou, zelenou nebo jinou barvu) jsme zatím nijak neovlivňovali.

V této kapitole si ukážeme, jak lze s pomocí funkcí \texttt{scale\_*\_*()} měnit škálování a prvky, které pomáhají čtenáři převést vizualizaci zpět do dat.

Pro tyto účely budeme používat jednoduchou datovou tabulku se 3 pozorováními a 4 sloupci \texttt{x}, \texttt{y}, \texttt{z} a \texttt{w}\ldots{}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\OtherTok{\textless{}{-}} \FunctionTok{data\_frame}\NormalTok{(}
    \AttributeTok{x =} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{2}\NormalTok{,}\DecValTok{3}\NormalTok{),}
    \AttributeTok{y =} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{1}\NormalTok{,}\DecValTok{1}\NormalTok{),}
    \AttributeTok{z =} \FunctionTok{c}\NormalTok{(}\StringTok{"A"}\NormalTok{,}\StringTok{"B"}\NormalTok{,}\StringTok{"C"}\NormalTok{),}
    \AttributeTok{w =} \FunctionTok{c}\NormalTok{(}\SpecialCharTok{{-}}\DecValTok{1}\NormalTok{,}\DecValTok{0}\NormalTok{,}\DecValTok{1}\NormalTok{)}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\ldots a jednoduchý bodový graf:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-21-1.pdf}

\texttt{ggplot2} namapoval data na estetiky (pozice) a vykreslil osy, které čtenáři umožňují číst data. Obrázek je takový, jaký asi všichni očekávají. Nicméně to nemusí být to, co uživatel chce. Co může chtít změnit? Například:

\begin{itemize}
\tightlist
\item
  jméno škály (\texttt{name})
\item
  popisky na ose (\texttt{labels})
\item
  pozice ``hlavních'' popisků na ose (\texttt{breaks})
\item
  pozice ``pomocných'' popisků/čar na ose (\texttt{minor\_breaks})
\item
  interval zobrazený na obrázku -- ``jak dlouhá'' má být osa (\texttt{limits})
\item
  pozici osy (\texttt{position})
\item
  transformaci hodnot na ose -- například zobrazení logaritmu pozorovaných hodnot (\texttt{trans})
\item
  zobrazení sekundární osy (\texttt{sec.axis})
\end{itemize}

Úplný výčet možností se samozřejmě liší podle estetiky.

Mapování se řídí pomocí funkcí \texttt{scale\_*\_*()}, která se podobně jako \texttt{geom\_()} připojují k volání \texttt{ggplot()} pomocí funkce \texttt{+}. Jména funkcí \texttt{scale\_*\_*()} se mohou zdá komplikovaná, ale opak je pravdou. Ve jejích jménech je totiž systém. Jméno funkce se sestává ze tří částí, spojených znakem "\_":

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Všechna jména začínají \texttt{scale}
\item
  Druhá část jména je jméno estetiky, kterou chceme kontrolovat
\item
  Poslední část jména je jméno konkrétní škály (to je potřeba si občas pamatovat nebo najít)
\end{enumerate}

Pokud bychom například chtěli změnit jméno osy x (estetika \texttt{x}) na našem obrázku, potom budeme chtít použít funkci:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{scale\_x\_continuous}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

První část jména je daná, druhá je jasná a třetí odkazuje na povahu proměnná \texttt{x} v tabulce \texttt{xtable}, která je spojitá. (Takto pěkně ale jména škály nefungují vždy. Občas je třeba hledat.)

Pokud známe jméno, je z poloviny vyhráno:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{scale\_x\_continuous}\NormalTok{(}\AttributeTok{name =} \StringTok{"Tohle je osa x"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-23-1.pdf}

Jak bylo zmíněno výše, pomocí škál je možné nastavit velké množství parametrů:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{scale\_x\_continuous}\NormalTok{(}
        \AttributeTok{name =} \StringTok{"Tohle je osa x"}\NormalTok{,}
        \AttributeTok{breaks =} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{2}\NormalTok{,}\DecValTok{3}\NormalTok{),}
        \AttributeTok{labels =} \FunctionTok{c}\NormalTok{(}\StringTok{"málo"}\NormalTok{,}\StringTok{"víc"}\NormalTok{,}\StringTok{"málo"}\NormalTok{),}
        \AttributeTok{limits =} \FunctionTok{c}\NormalTok{(}\DecValTok{0}\NormalTok{,}\DecValTok{4}\NormalTok{),}
        \AttributeTok{position =} \StringTok{"top"}
\NormalTok{        )}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-24-1.pdf}

Poněkud specifické je nastavení transformace. V praxi se často používá logaritmická transformace:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{scale\_x\_continuous}\NormalTok{(}\AttributeTok{trans =} \StringTok{"log10"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-25-1.pdf}

Řada transformací je pro uživatele připravená (viz \texttt{?scale\_x\_continuous()}). Uživatel má navíc možnost vytvořit vlastní transformace. Pro nejčastější transformace má \texttt{ggplot2} předpřipravené škály -- například \texttt{log10} nebo \texttt{reverse}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{scale\_x\_log10}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-26-1.pdf}

V předchozích příkladech jsme volali funkci \texttt{scale\_x\_*()} pro nastavení mapování estetiky \texttt{x}. Nicméně ani jednou jsme neupravovali estetiku \texttt{y} a taky to fungovalo. Jak je to možné? Pokud není funkce \texttt{scale\_*\_*()} explicitně volána uživatelem, \texttt{ggplot2} odhadne, která funkce je nejvhodnější a zavolá ji interně sám. Volání:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

Je tak ve výsledku ekvivalentní k:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{scale\_x\_continuous}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{scale\_y\_continuous}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

Pokud se změní povaha podkladových dat, potom se i \texttt{ggplot2} rozhodne volat jinou funkci \texttt{scale\_*\_*()}. V případě volání:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =} \FunctionTok{factor}\NormalTok{(x), }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

kde proměnná \texttt{x} je konvertována na faktor. Vrátí \texttt{ggplot2} obrázek ekvivalentní volání:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =} \FunctionTok{factor}\NormalTok{(x), }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{scale\_x\_discrete}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{scale\_y\_continuous}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-30-1.pdf}

\texttt{ggplot2} v tomto případě volá škálu vytvořenou pro mapování diskrétních proměnných.

\hypertarget{mapovuxe1nuxed-barev-estetiky-colour-a-fill}{%
\subsubsection{\texorpdfstring{Mapování barev (estetiky \texttt{colour} a \texttt{fill})}{Mapování barev (estetiky colour a fill)}}\label{mapovuxe1nuxed-barev-estetiky-colour-a-fill}}

Pomocí funkcí \texttt{scale\_*\_*()} lze měnit mapování všech estetik. Mezi nejčastější upravované škály patří bezesporu barvy, které se mapují v estetikách \texttt{color}/\texttt{colour} a \texttt{fill}.

Poznámka: \texttt{ggplot2} neumí a podle jeho tvůrců nikdy nebude umět vybarvovat texturou (``šrafováním'').

Pro ilustraci těchto estetik použijeme následující podobu bodového grafu:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y, }\AttributeTok{color =}\NormalTok{ z, }\AttributeTok{fill =}\NormalTok{ w)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{(}
        \AttributeTok{shape =} \DecValTok{21}\NormalTok{,}
        \AttributeTok{stroke =} \DecValTok{3}\NormalTok{,}
        \AttributeTok{size =} \DecValTok{10}
\NormalTok{        ) }\SpecialCharTok{+}
    \FunctionTok{scale\_x\_continuous}\NormalTok{(}
        \AttributeTok{limits =} \FunctionTok{c}\NormalTok{(}\FloatTok{0.5}\NormalTok{,}\FloatTok{3.5}\NormalTok{)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{theme}\NormalTok{(}
        \AttributeTok{legend.direction =} \StringTok{"horizontal"}
\NormalTok{    ) }\OtherTok{{-}\textgreater{}}\NormalTok{ p}

\NormalTok{p}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-31-1.pdf}

Výsledná podoba obrázku je ovlivněna funkcí \texttt{theme()}. Její fungování je popsáno níže. Celá struktura je přiřazená do proměnné \texttt{p}. S tou budeme nadále pracovat.

Tento graf mapuje proměnné \texttt{z} a \texttt{w} na estetiky \texttt{color} a \texttt{fill}. Ostatní estetiky jsou nastaveny a jsou pro všechny body v grafu shodné.

Proměnná \texttt{z} a \texttt{w} se liší ve své povaze. \texttt{w}je spojitá proměnná a \texttt{z} je kategoriální. Práce s barvami by se obecně měla řídit podle povahy zobrazovaných dat:

\begin{itemize}
\tightlist
\item
  Spojité proměnné se typicky zobrazují barevným přechodem -- jak vidíte na obrázku, základní volbou \texttt{ggplot2} je přechod z tmavě do světle modré.
\item
  Kategoriální proměnné, jejichž hodnoty jsou ``na stejné úrovni''. Příkladem takové proměnné mohou být například značky automobilů. V takovém případě je zvolit barvy, které jsou pro vnímání člověka ``stejně daleko'' od sebe. Příkladem takového výběru barev může být proměnná \texttt{z} v ukázkovém obrázku.
\item
  Posledním typem jsou kategoriální proměnné, které vyjadřují sekvenci (např.: malá, střední, velká). V takovém případě je vhodné volit barevný přechod, který je také rozdělen do kroků, které musí být tak velké, aby byly pro člověka jasně odlišitelné.
\end{itemize}

Při volbě barev je také užitečné myslet na barvoslepé a na tisk na černobílé tiskárně. Jiné barvy jsou také vhodné pro plochy a jiné pro body. Ve výsledku je výběr barev nesmírně složitý. Najít sekvenci barev pro 10 úrovní je těžké, pro 20 úrovní je to nemožné. Moudrým postupem je proto používat uměřený počet barev (úrovní) a v jejich volbě vycházet z doporučení odborníků.

\hypertarget{spojituxe9-promux11bnnuxe9}{%
\paragraph{Spojité proměnné}\label{spojituxe9-promux11bnnuxe9}}

Typickým postupem zobrazování spojité proměnné v barvě je použití barevného přechodu (gradientu) mezi dvěma nebo více barvami. \texttt{ggplot2} nabízí hned 4 škály založené na gradientech:

\texttt{scale\_*\_gradient()} (identické se \texttt{scale\_*\_continuous()}) je základní volbou, po které u spojitých proměnných \texttt{ggplot2} sáhne, pokud uživatel neporoučí jinak. Vykresluje přechod mezi dvěma barvami, které jsou nastavené parametry \texttt{low} a \texttt{high}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_fill\_gradient}\NormalTok{(}\AttributeTok{low =} \StringTok{"hotpink"}\NormalTok{, }\AttributeTok{high =} \StringTok{"\#56B1F7"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-32-1.pdf}

V příkladu je nastaven přechod z tmavě poníkové do modré. Barva je vždy definována jako řetězec (nebo funkcí, která řetězec nebo jejich vektor vytvoří) -- a to buď svým jménem (\texttt{"hotpink"}) nebo RGB kódem (\texttt{"\#56B1F7"}).

\texttt{scale\_*\_gradient2()} je derivátem \texttt{scale\_*\_gradient()} umožňuje vytvořit přechod přes tři barvy (\texttt{low}, \texttt{mid}, \texttt{high}) a specifikovat pozici středního bodu parametrem \texttt{midpoint}. (Parametr \texttt{midpoint} je defaultně nastaven na hodnotu 0.)

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_fill\_gradient2}\NormalTok{(}\AttributeTok{midpoint =} \FloatTok{0.5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-33-1.pdf}

\texttt{scale\_*\_gradientn()} umožňuje použít přechod přes tolik barev, kolik si jen srdce uživatele přeje. Z tohoto důvodu neobsahuje žádné základní nastavení:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_fill\_gradientn}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Error in scale_fill_gradientn(): argument "colors" is missing, with no default
\end{verbatim}

Uživatel musí prostřednictvím parametru \texttt{colours} zadat vektor barev, které se mají použít. Domnívám se, že pro uživatele -- neodborníka -- se jedná o nemožný úkol. Je však možné použít předpřipravené palety, které jsou součástí mnoha balíků. Následující příklad využívá paletu \texttt{inferno} z balíku \textbf{viridis}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_fill\_gradientn}\NormalTok{(}\AttributeTok{colours =}\NormalTok{ viridis}\SpecialCharTok{::}\FunctionTok{inferno}\NormalTok{(}\DecValTok{3}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-35-1.pdf}

Využití \texttt{scale\_*\_gradientn()} je vhodné spíše v plochách. Nicméně i tam je dobré spolehnout na rady odborníků. Příklad ``plošného'' obrázku:

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-36-1.pdf}

Na radách odborníků je zcela postaven \texttt{scale\_*\_distiller()}. Pracuje s ručně vybranými diskrétními paletami, které jsou dostupné na \url{http://colorbrewer2.org/}. \texttt{scale\_*\_distiller()} tyto diskrétní palety adaptuje i pro spojité proměnné. Rozumný způsob práce je na webu zvolit vhodnou barevnou škálu a její jméno specifikovat v parametru \texttt{palette}. Ten um pracovat s číslem palety i s jejím jménem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_fill\_distiller}\NormalTok{(}\AttributeTok{palette =} \StringTok{"YlGnBu"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-37-1.pdf}

Parametrem \texttt{direction}, který nabývá hodnot \texttt{1} nebo \texttt{-1}, lze pořadí barev obrátit:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_fill\_distiller}\NormalTok{(}\AttributeTok{palette =} \StringTok{"YlGnBu"}\NormalTok{, }\AttributeTok{direction =} \DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-38-1.pdf}

Používání \url{http://colorbrewer2.org/} lze doporučit v maximální rozumné míře.

\hypertarget{diskruxe9tnuxed-promux11bnnuxe9}{%
\paragraph{Diskrétní proměnné}\label{diskruxe9tnuxed-promux11bnnuxe9}}

Pro diskrétní proměnné je výchozí volbou \texttt{scale\_*\_hue()}. Tato škála vybírá od sebe stejně vzdálené barvy na ``HCL wheel'' (viz např. Wikipedie). Teoreticky je tak schopna vytvořit barevné schéma pro prakticky neomezený počet kategorií. V praxi od sebe budou barvy při vyšším počtu kategorií nerozpoznatelné.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_color\_hue}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-39-1.pdf}

\texttt{scale\_*\_hue()} umožňuje vybrat výchozí bod na HCL wheel a parametrem \texttt{direction} směr, jakým se na něm výběr pohybuje:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_color\_hue}\NormalTok{(}\AttributeTok{direction =} \SpecialCharTok{{-}}\DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-40-1.pdf}

Zejména při finalizaci grafických výstupů je vhodné poohlédnout se po předpřipravených paletách. V samotném \texttt{ggplot2} jde o \texttt{scale\_*\_brewer()} -- bratra \texttt{scale\_*\_distiller()} pro diskrétní veličiny.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_color\_brewer}\NormalTok{(}\AttributeTok{palette =} \StringTok{"Set1"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-41-1.pdf}

Speciální škálou je \texttt{scale\_*\_grey()}. Ta, jak název napovídá, mapuje do odstínů šedé:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_color\_grey}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-42-1.pdf}

Speciálními případy škál jsou \texttt{scale\_*\_manual()} a \texttt{scale\_*\_identity()}. \texttt{scale\_*\_manual()} umožňuje uživateli vytvořit si vlastní škálu. U barev bude tato možnost využívána asi jen zřídka. Za určitých okolností se však může hodit u jiných estetik -- například u \texttt{shape}.

\texttt{scale\_*\_identity()} dokáže vzít proměnnou z datové tabulky a použít ji ``tak jak je'' pro vykreslení barev, tvarů a podobně.

\hypertarget{co-jsme-zamlux10deli}{%
\subsubsection{Co jsme zamlčeli\ldots{}}\label{co-jsme-zamlux10deli}}

Všechny krásné škálovací funkce \texttt{scale\_*\_*()} v posledku využívají služeb konstruktorových funkcí \texttt{discrete\_scale()} a \texttt{continuous\_scale()}. S těmito funkcemi komunikujete ze \texttt{scale\_*\_*()} přes argument \texttt{...}. Pokud tedy budete chtít provádět něco složitějšího, tak se vyplatí projít si nápovědu právě k těmto konstruktorovým funkcím.

\hypertarget{grupovuxe1nuxed}{%
\section{Grupování}\label{grupovuxe1nuxed}}

U některých funkcí \texttt{geom\_*()} je mezi estetikami uvedena jedna s názvem \texttt{group}. Lehko si můžete ověřit, že se nijak nepřekládá do vizuální podoby. Její funkce je totiž jiná. Sděluje \texttt{ggplot2}, že určitá skupina pozorování ``patří k sobě'' -- tvoří jednu skupinu.

Praktické využití lze ilustrovat na proložení křivky v tabulce \texttt{diamonds}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{geom\_smooth}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-43-1.pdf}

V tomto případě se proložila křivka přes všechny pozorování. Můžeme se ale chtít podívat, jestli je závislost stejná pro různé \emph{druhy} kamenů -- například pro skupiny definované kvalitou řezu (\texttt{cut}). V tomto případě použijeme estetiku \texttt{group}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price, }\AttributeTok{group =}\NormalTok{ cut)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{geom\_smooth}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-44-1.pdf}

V tomto případě \texttt{geom\_smooth()}, který estetice \texttt{group} rozumí, pracuje s každou skupinou vymezenou hodnotou kategoriální proměnné \texttt{cut} zvlášť. Fakticky každou skupinu proloží její vlastní křivkou.

V praxi je často užitečné pro zpřehlednění využít možnosti mapování jedné proměnné na více estetik:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price, }\AttributeTok{group =}\NormalTok{ cut, }\AttributeTok{color =}\NormalTok{ cut)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{geom\_smooth}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-45-1.pdf}

Všiměte si že v tomto případě dostanete stejný výsledek i při namapování kategorické proměnné na estetiku \texttt{color}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price, }\AttributeTok{color =}\NormalTok{ cut)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{geom\_smooth}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-46-1.pdf}

\hypertarget{statistickuxe9-transformace}{%
\section{Statistické transformace}\label{statistickuxe9-transformace}}

\texttt{ggplot2} umožňuje nejen vykreslovat samotná data, ale i jejich interně vytvořené statistické transformace. Příkladem může být například proložení křivkou (\texttt{geom\_smooth()}). Jejich tvorbu mají na starosti funkce \texttt{stat\_*()}. Vztah mezi funkcemi \texttt{geom\_*()} a \texttt{stat\_*()} není úplně jasný. Každá transformace (\texttt{stat}) má svůj výchozí (přednastavený) geometrický tvar (\texttt{geom}) a každý \texttt{geom} má svůj výchozí \texttt{stat}. V některých případech tak může být jedno, jestli uživatel volá \texttt{geom} nebo ekvivalentní \texttt{stat}, Viz například použití \texttt{stat\_smooth()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{stat\_smooth}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-47-1.pdf}

Tato nejednoznačnost vymezení toho, co vlastně dělá \texttt{stat\_*()} a co \texttt{geom\_*()} je velmi otravnou nedokonalostí v návrhu \texttt{ggplot2} (a v \texttt{ggvis} je již vyřešena). Pokud není nevyhnutelné volat přímo \texttt{stat\_*()} nutné, je lepší vždy používat funkce \texttt{geom\_*()}.

Pro přímé volání \texttt{stat\_*()} existovaly v podstatě dva důvody:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  potřeba specifických nastavení statistických transformací
\item
  potřeba použití jiného než standardního geomu pro vykreslení statistické transformace
\end{enumerate}

Pohledem do nápovědy zjistíte, že \texttt{stat\_smooth()} umožňuje mnohem více nastavení vyhlazování:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{geom\_smooth}\NormalTok{(}\AttributeTok{mapping =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{data =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{stat =} \StringTok{"smooth"}\NormalTok{,}
  \AttributeTok{position =} \StringTok{"identity"}\NormalTok{, ..., }\AttributeTok{method =} \StringTok{"auto"}\NormalTok{, }\AttributeTok{formula =}\NormalTok{ y }\SpecialCharTok{\textasciitilde{}}\NormalTok{ x,}
  \AttributeTok{se =} \ConstantTok{TRUE}\NormalTok{, }\AttributeTok{na.rm =} \ConstantTok{FALSE}\NormalTok{, }\AttributeTok{show.legend =} \ConstantTok{NA}\NormalTok{, }\AttributeTok{inherit.aes =} \ConstantTok{TRUE}\NormalTok{)}

\FunctionTok{stat\_smooth}\NormalTok{(}\AttributeTok{mapping =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{data =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{geom =} \StringTok{"smooth"}\NormalTok{,}
  \AttributeTok{position =} \StringTok{"identity"}\NormalTok{, ..., }\AttributeTok{method =} \StringTok{"auto"}\NormalTok{, }\AttributeTok{formula =}\NormalTok{ y }\SpecialCharTok{\textasciitilde{}}\NormalTok{ x,}
  \AttributeTok{se =} \ConstantTok{TRUE}\NormalTok{, }\AttributeTok{n =} \DecValTok{80}\NormalTok{, }\AttributeTok{span =} \FloatTok{0.75}\NormalTok{, }\AttributeTok{fullrange =} \ConstantTok{FALSE}\NormalTok{, }\AttributeTok{level =} \FloatTok{0.95}\NormalTok{,}
  \AttributeTok{method.args =} \FunctionTok{list}\NormalTok{(), }\AttributeTok{na.rm =} \ConstantTok{FALSE}\NormalTok{, }\AttributeTok{show.legend =} \ConstantTok{NA}\NormalTok{,}
  \AttributeTok{inherit.aes =} \ConstantTok{TRUE}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

V novějších verzích \texttt{ggplot2} se však již dají zpravidla předávat hodnoty parametrů pro \texttt{stat\_*()} prostřednictvím \texttt{...} v \texttt{geom\_*()}. Tato možnost prakticky eliminuje potřebu volat \texttt{stat\_*()} funkce přímo kvůli nastavení statistických transformací.

Druhý důvod pro přímé použití \texttt{stat\_*()} funkce však stále trvá. V některých případech můžete potřebovat použít pro vyreslení transformace netypický geom. Příkladem může být například zobrazování jádrové hustoty rozdělení dvou proměnných nikoliv pomocí vrstevnic (standardní zobrazení), ale pomocí barevných polygonů. (Výsledkem by byly například barevné plochy s barvou sytější tam, kde je odhadnuta vyšší hustota.) Tyto úlohy jsou však bezpochyby z kapitoly pro pokročilé.

\hypertarget{pozicovuxe1nuxed}{%
\section{Pozicování}\label{pozicovuxe1nuxed}}

V \texttt{ggplotu2} existuje hned několik způsobů, jak je možné ovlivnit pozici vykresleného geomu (tj. geometrického objektu reprezentujícího data) na stránce. První možností bylo použití škál -- například jejich logaritmická transformace.

\texttt{ggplot2} však v tomto ohledu nabízí mnohem více možností. Místem kde začít hledat je parametr \texttt{position} ve funkci \texttt{layer()}. Smyslem jeho použití je předejít překryvu pozorování ve výsledném obrázku. Parametr může nabývat následujících hodnot:

\begin{itemize}
\tightlist
\item
  \texttt{identity}\ldots je základní volba pro většinu funkcí \texttt{geom\_*()}. Prakticky znamená, že z hlediska modifikace pozice geomu předává instrukci ``nedělej nic a kresli na skutečnou pozici''.
\item
  \texttt{jitter}\ldots ke skutečné pozici přidává náhodnou chybu
\item
  \texttt{dodge}\ldots geomy skládá vedle sebe
\item
  \texttt{stack}\ldots staví komínky -- skládá geomy nad sebe
\item
  \texttt{nudge}\ldots u překrývajících se geomů přidává ke skutečné pozici definovanou vzdálenost na ose \texttt{x} a \texttt{y}
\item
  \texttt{jitterdodge}\ldots kombinuje \texttt{jitter} a \texttt{dodge}
\end{itemize}

V následujícím textu jsou blíže ukázány nejčastěji používané varianty změny pozic: \texttt{jitter}, \texttt{dodge}, \texttt{stack} a navíc poněkud specifická varianta \texttt{fill}. Varianty \texttt{nudge} a \texttt{jitterdodge} jsou specifické pro určité méně geomy a jejich přímé volání je v podstatě výjimečné.

\hypertarget{jitter}{%
\subsection{\texorpdfstring{\texttt{jitter}}{jitter}}\label{jitter}}

\texttt{position\ =\ "jitter"} je populární volba zejména u bodových grafů, ve kterých je velký problém s overplottingem. Toto použití je tak typické, že existuje dokonce speciální \texttt{geom\_*()} funkce: \texttt{geom\_jitter()}. Ta je ekvivalentní k \texttt{geom\_point(position\ =\ "jitter")}.

\texttt{geom\_jitter()} přidává ke skutečné pozici pozorování náhodnou složku, která je generovaná z uniformního rozdělení:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_jitter}\NormalTok{(}\AttributeTok{color =} \StringTok{"red"}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-49-1.pdf}

V obrátku vidíte skutečnou pozici pozorování vykreslenou pomocí \texttt{geom\_point()} a červené tečky ukazující posunuté hodnoty vykreslené pomocí \texttt{geom\_jitter()}. Protože je chyba náhodná, bude obrázek při každém vykreslení vypadat jinak.

Pomocí parametrů \texttt{width} a \texttt{height} je možná nastavit šířku a výšku obdélníku, ve kterém se posunutá pozorování budou nacházet. Protože se náhodná složka generuje z uniformního rozdělení, je každý posun stejně pravděpodobný. Skutečná pozorovaná hodnota je pak právě ve středu obdélníku. To ilustruje následující obrázek:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable2 }\OtherTok{\textless{}{-}} \FunctionTok{data\_frame}\NormalTok{(}
    \AttributeTok{x =} \FunctionTok{rep}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{,}\DecValTok{1000}\NormalTok{),}
    \AttributeTok{y =} \FunctionTok{rep}\NormalTok{(}\DecValTok{1}\SpecialCharTok{:}\DecValTok{2}\NormalTok{,}\DecValTok{1000}\NormalTok{)}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{xtable2 }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_jitter}\NormalTok{(}
        \AttributeTok{alpha =} \FloatTok{0.05}\NormalTok{,}
        \AttributeTok{color =} \StringTok{"red"}
\NormalTok{        ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-51-1.pdf}

Posunutá pozorování (červené tečky) tvoří mračno rovnoměrně vyplňující celý obdélník za pozorovanou hodnotou (černá tečka), která je přesně v jeho středu.

\hypertarget{stack}{%
\subsection{\texorpdfstring{\texttt{stack}}{stack}}\label{stack}}

Typické použití této změny této modifikace pozice je u sloupcových grafů. Ty se v \texttt{ggplot2} tvoří pomocí \texttt{geom\_bar()} a jejich základní nestavení je, že mají být použity k vykreslení rozdělení diskrétní proměnné.

Pro použití \texttt{geom\_bar()} vytvoříme novou tabulku \texttt{occupation}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{occupation }\OtherTok{\textless{}{-}} \FunctionTok{data\_frame}\NormalTok{(}
    \AttributeTok{sex =} \FunctionTok{rep}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"male"}\NormalTok{,}\StringTok{"female"}\NormalTok{),}\DecValTok{100}\NormalTok{),}
    \AttributeTok{occupation =} \FunctionTok{sample}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"A"}\NormalTok{,}\StringTok{"B"}\NormalTok{,}\StringTok{"C"}\NormalTok{,}\StringTok{"D"}\NormalTok{), }\DecValTok{200}\NormalTok{, }\AttributeTok{replace =} \ConstantTok{TRUE}\NormalTok{, }\AttributeTok{prob =} \FunctionTok{abs}\NormalTok{(}\FunctionTok{rnorm}\NormalTok{(}\DecValTok{4}\NormalTok{))),}
    \AttributeTok{age =} \FunctionTok{sample}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"old"}\NormalTok{,}\StringTok{"young"}\NormalTok{), }\DecValTok{200}\NormalTok{, }\AttributeTok{replace =} \ConstantTok{TRUE}\NormalTok{)}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Tabulka obsahuje povolání (A, B, C nebo D), pohlaví a věkovou kohortu 200 lidí. Zajímá nás rozdělení povolání ve vzorku:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{occupation }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ occupation)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_bar}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-53-1.pdf}

\texttt{geom\_bar()} v základním nastavení, tedy se \texttt{stat\ =\ "count"}, provádí statistickou transformaci dat. Zjistí absolutní četnost jednotlivých variant proměnné v estetice \texttt{x} a tyto četnosti následně vykreslí formou sloupcového grafu.

Obrázek momentálně nijak nezohledňuje pohlaví, ale to se dá změnit. Lze ho namapovat například (a typicky) na estetiku \texttt{fill}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{occupation }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ occupation, }\AttributeTok{fill =}\NormalTok{ sex)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_bar}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-54-1.pdf}

Ve výsledku dodá statistická transformace provedená \texttt{stat\_count()} pro každé povolání dvě hodnoty: počet mužů a počet žen. Ty by se v logicky měly kreslit přes sebe -- patří v obrázku na jedno místo. Očekávali bychom tedy tento obrázek:

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-55-1.pdf}

Takový obrázek však není příliš užitečný, protože poskytuje spolehlivou informaci pouze o maximálních hodnotách. Proto již v základním nastavení \texttt{geom\_bar()} používá \texttt{position\ =\ "stack}, která počet žen a mužů postaví nad sebe -- do jednoho komínku.

Poznámka: ``Špatný'' obrázek můžete vykreslit s \texttt{geom\_bar(position\ =\ "identity)}.

\hypertarget{dodge}{%
\subsection{\texorpdfstring{\texttt{dodge}}{dodge}}\label{dodge}}

Dalším typickým řešením u sloupcových grafů je vykreslení hodnot vedle sebe. Tento způsob čtenáři lépe předává informaci o počtu mužů a žen napříč povoláními. Horizontální posunutí sloupců zajišťuje \texttt{position\ =\ "dodge"}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{occupation }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ occupation, }\AttributeTok{fill =}\NormalTok{ sex)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_bar}\NormalTok{(}\AttributeTok{position =} \StringTok{"dodge"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-56-1.pdf}

\hypertarget{fill}{%
\subsection{\texorpdfstring{\texttt{fill}}{fill}}\label{fill}}

Poněkud specifickou úpravou pozice je \texttt{fill}, která upravuje nejen pozici, ale vlastně provádí i další statistickou transformaci. Nevrací totiž absolutní, ale relativní četnost:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{occupation }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ occupation, }\AttributeTok{fill =}\NormalTok{ sex)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_bar}\NormalTok{(}\AttributeTok{position =} \StringTok{"fill"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-57-1.pdf}

\hypertarget{facetovuxe1nuxed-na-pux16fli-cesty-mezi-grupovuxe1nuxedm-a-pozicovuxe1nuxedm}{%
\subsection{Facetování: na půli cesty mezi grupováním a pozicováním}\label{facetovuxe1nuxed-na-pux16fli-cesty-mezi-grupovuxe1nuxedm-a-pozicovuxe1nuxedm}}

Výše popsané pozicování mělo pozici geomů vlastně v rámci jednoho obrázku. Facetování k problému přistupuje jinak -- rozlamuje původně jeden obrázek na více dílčích obrázků (facet). \texttt{ggplot2} umožňuje vytvářet buď matice dílčích obrázků pomocí \texttt{facet\_grid()} nebo prosté rozlomení do více obrázků pomocí \texttt{facet\_wrap()}.

Nejjednodušší příklad je použití \texttt{facet\_wrap()}. Řekněme, že budeme chtít rozdělit obrázek s rozdělením povolání podle pohlaví:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{occupation }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ occupation)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_bar}\NormalTok{() }\OtherTok{{-}\textgreater{}}\NormalTok{ p}

\NormalTok{p }\SpecialCharTok{+} \FunctionTok{facet\_wrap}\NormalTok{(}\StringTok{"sex"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-58-1.pdf}

\texttt{facet\_wrap()} rozdělil celkový obrázek na dva dílčí podle hodnot proměnné \texttt{sex}. Ta je v příkladu určena svým jménem (\emph{character}). Další možností je její určení pomocí jednostranné rovnice (\emph{formula}, blíže viz přednáška o ekonometrii v R):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{facet\_wrap}\NormalTok{(}\SpecialCharTok{\textasciitilde{}}\NormalTok{ sex)}
\end{Highlighting}
\end{Shaded}

Vytvářet dílčí obrázky lze i podle kombinace více proměnných -- můžeme chtít například samostatné dílčí obrázky pro kombinaci pohlaví a věku. V tomto případě se pro specifikaci proměnných použije vektor jejich jmen:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{facet\_wrap}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"sex"}\NormalTok{,}\StringTok{"age"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-60-1.pdf}

Nebo alternativně:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{facet\_wrap}\NormalTok{(}\SpecialCharTok{\textasciitilde{}}\NormalTok{ sex }\SpecialCharTok{+}\NormalTok{ age)}
\end{Highlighting}
\end{Shaded}

Použít pro tyto aplikace \texttt{facet\_wrap()} je možné, ale často je vhodnější sáhnout po \texttt{facet\_grid()}, který je přímo navržen pro rozlomení obrázku podle kombinace více proměnných. \texttt{facet\_grid()} vyžaduje specifikaci facetování pomocí objektu třídy \texttt{formula}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{facet\_grid}\NormalTok{(sex }\SpecialCharTok{\textasciitilde{}}\NormalTok{ age)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-62-1.pdf}

Na levé straně rovnice (na levé straně \texttt{\textasciitilde{}}) je proměnná (nebo jejich kombinace spojená \texttt{+}), která má tvořit řádky a na levé straně je proměnná nebo jejich kombinace, která má tvořit sloupce.

Funkce vytvářející facetování mají i další užitečné parametry. Pro \texttt{facet\_wrap()} jsou specifické parametry \texttt{ncol} a \texttt{nrow}, které určují formát výstupní tabulky dílčích obrázků -- kolik má mít sloupců a kolik řádků. Stačí přitom zadat jen jeden z těchto parametrů:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{facet\_wrap}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"sex"}\NormalTok{,}\StringTok{"age"}\NormalTok{), }\AttributeTok{nrow =} \DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-63-1.pdf}

Užitečný, ale pro správné čtení dat velmi ošemetný, parametr je \texttt{scales}. Ten umožňuje uvolnit škály v jednotlivých dílčích obrázcích. Základní hodnotou je \texttt{fixed}. V tomto případě jsou měřítka na všech dílčích obrázcích stejná. Varianty \texttt{free}, \texttt{free\_y} a \texttt{free\_x} umožňují uvolnit měřítka na všech osách nebo jen na ose \texttt{x} popřípadě \texttt{y}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{facet\_wrap}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"sex"}\NormalTok{,}\StringTok{"age"}\NormalTok{), }\AttributeTok{nrow =} \DecValTok{1}\NormalTok{, }\AttributeTok{scales =} \StringTok{"free\_y"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-64-1.pdf}

Příklad ilustruje, že uvolnění os může být pro čtenáře velmi zavádějící. Stejná výška sloupce totiž v různých dílčích obrázcích znamená jinou pozorovanou hodnotu.

\hypertarget{souux159adnicovuxe9-systuxe9my}{%
\section{Souřadnicové systémy}\label{souux159adnicovuxe9-systuxe9my}}

\emph{ggplot2} podporuje řadu souřadnicových systémů. Základní volbou je lineární \texttt{coord\_cartesian()}, ale podporovány jsou i nelineární souřadnicové systémy, které se ovšem používají pouze ve velmi specifických případech jako je například vykreslování map (\texttt{coord\_map()}). Dalším příkladem nelineárního systému je \texttt{coord\_polar()}.

Základní volbou aplikovanou v téměř všech voláních \emph{ggplot2} je bezpochyby lineární systém, ve kterém je pozice prvků určena jejich souřadnicemi na ose \texttt{x} a \texttt{y}. Základní funkcí je \texttt{coord\_cartesian()}, ale \emph{ggplot2} obsahuje i její různé mutace a transformace:

\begin{itemize}
\tightlist
\item
  \texttt{coord\_fixed()} udržuje konstantní zadaný poměr stran.
\item
  \texttt{coord\_equal()} je zkratka pro \texttt{coord\_fixed()} s poměrem stran 1.
\item
  \texttt{coord\_flip()} prohazuje osy \texttt{x} a \texttt{y}.
\item
  \texttt{coord\_trans()} umožňuje provést transformaci os.
\item
  \texttt{coord\_sf()} je speciální funkce pro práci s mapami.
\end{itemize}

Fungování \texttt{coord\_flip()} je možné ilustrovat pomocí jednoduchého bodového grafu. V definici mapování je váha (\texttt{carat}) namapována na osu \texttt{x} a cena na osu \texttt{y}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{diamonds }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ carat, }\AttributeTok{y =}\NormalTok{ price)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\OtherTok{{-}\textgreater{}}\NormalTok{ p}
\end{Highlighting}
\end{Shaded}

Použití \texttt{coord\_flip()} prohodí osy \texttt{x} a \texttt{y} -- výsledek tedy odpovídá použití \texttt{aes(y\ =\ carat,\ x\ =\ price)}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{coord\_flip}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-66-1.pdf}

\texttt{coord\_flip()} je užitečné u některých specifických geomů -- například u boxplotů, která zobrazují základní charakteristiky rozdělení spojité proměnné.

\texttt{coord\_trans()} umožňuje transformovat osy podobným způsobem jako \texttt{scale\_*\_*()} funkce. Stejně jako ostatní funkce odvozené od \texttt{coord\_cartesian()} umožňuje nastavit interval zobrazený na osách. Podobnou možnost mají opět i \texttt{scale\_*\_*()} funkce.

Nabízí se tedy otázka, na co jsou vlastně funkce \texttt{coord\_*()} užitečné. Pro demonstraci odpovědi nasimulujeme velmi specifickou tabulku:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{cltable }\OtherTok{\textless{}{-}} \FunctionTok{data\_frame}\NormalTok{(}
    \AttributeTok{x =} \FunctionTok{c}\NormalTok{(}
        \FunctionTok{rnorm}\NormalTok{(}\DecValTok{300}\NormalTok{, }\AttributeTok{sd =} \DecValTok{2}\NormalTok{),}
        \FunctionTok{rnorm}\NormalTok{(}\DecValTok{40}\NormalTok{, }\AttributeTok{sd =} \FloatTok{0.5}\NormalTok{) }\SpecialCharTok{+} \DecValTok{10}
\NormalTok{        ),}
    \AttributeTok{y =} \FunctionTok{c}\NormalTok{(}
        \FunctionTok{rnorm}\NormalTok{(}\DecValTok{300}\NormalTok{, }\AttributeTok{sd =} \DecValTok{1}\NormalTok{),}
        \FunctionTok{rnorm}\NormalTok{(}\DecValTok{40}\NormalTok{, }\AttributeTok{sd =} \FloatTok{0.5}\NormalTok{) }\SpecialCharTok{+} \DecValTok{5}
\NormalTok{        )}
\NormalTok{)}

\NormalTok{cltable }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ x, }\AttributeTok{y =}\NormalTok{ y)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{geom\_smooth}\NormalTok{(}\AttributeTok{method =} \StringTok{"lm"}\NormalTok{, }\AttributeTok{se =} \ConstantTok{FALSE}\NormalTok{) }\OtherTok{{-}\textgreater{}}\NormalTok{ p}
    
\NormalTok{p}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-67-1.pdf}

Simulovaná data obsahují dva shluky pozorování. Pokud je proložíme regresní přímkou (tj. vykreslíme statistickou transformaci dat) získáme (falešné) zdání existence rostoucího vztahu mezi veličinou na ose \texttt{x} a na ose \texttt{y}.

Řekněme, že z nějakých důvodů budeme chtít omezit zobrazené hodnoty na ose \texttt{x} na interval \([-5,5]\). To lez provést buď pomocí funkcí \texttt{scale\_x\_*()} nebo \texttt{coord\_*()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{scale\_x\_continuous}\NormalTok{(}\AttributeTok{limits =} \FunctionTok{c}\NormalTok{(}\SpecialCharTok{{-}}\DecValTok{5}\NormalTok{,}\DecValTok{5}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-68-1.pdf}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{coord\_cartesian}\NormalTok{(}\AttributeTok{xlim =} \FunctionTok{c}\NormalTok{(}\SpecialCharTok{{-}}\DecValTok{5}\NormalTok{,}\DecValTok{5}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-69-1.pdf}

Rozdíl je zjevný. Při použití \texttt{scale\_x\_*()} je regresní přímka prakticky vodorovná. Naopak při použití \texttt{coord\_*()} je stále rostoucí. Rozdíl je v tom, kdy je aplikované statistická transformace (v tomto případě vyhlazení). Při použití \texttt{scale\_*\_*()} funkce je nejprve omezen rozsah dat a následně je aplikována transformace. Výsledek tak může být zavádějící. Naproti tomu při použití \texttt{coord\_*()} je nejprve aplikována transformace a následně je omezen rozsah zobrazených dat. Transformace tak reflektuje i ta pozorování, která nejsou zobrazená.

\texttt{coord\_*()} tak nabízí možnost skutečně ``zazoomovat'' část obrázku, aniž by to ovlivnilo obrázek samotný.

\hypertarget{vzhled-obruxe1zkux16f}{%
\section{Vzhled obrázků}\label{vzhled-obruxe1zkux16f}}

Vzhled obrázků, nebo přesněji prvky, které nemají vztah k datům se v \emph{ggplot2} ovládají pomocí funkce \texttt{theme()}. Ta umožňuje změnit vzhled obrázků k nepoznání: můžete mít obrázek, který vypadá, jako by byl vytvořen v Excelu, Stata, nebo jako by vyšel v The Economist.

Funkce \texttt{theme()} má obrovské množství parametrů a nebylo by praktické je nastavovat vždy u každého obrázku. Proto v \emph{ggplot2} existuje řada předpřipravených kompletních témat (vzhledů). Například \texttt{theme\_bw()}, \texttt{theme\_classic()} nebo \texttt{theme\_void()}. Základní vzhled obrázků potom odpovídá \texttt{theme\_gray()}. Nápověda \emph{ggplot2} obsahuje hrubá doporučení, kdy je vhodné použít které téma.

\hypertarget{ukuxe1zky-pux159edpux159ipravenuxfdch-tuxe9mat}{%
\subsection{Ukázky předpřipravených témat}\label{ukuxe1zky-pux159edpux159ipravenuxfdch-tuxe9mat}}

Pro ukázky použijeme již známý sloupcový graf:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{occupation }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ occupation, }\AttributeTok{fill =}\NormalTok{ sex)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_bar}\NormalTok{() }\OtherTok{{-}\textgreater{}}\NormalTok{ p}
\end{Highlighting}
\end{Shaded}

Populární téma je \texttt{theme\_bw()}, které \emph{ggplot2} doporučuje například pro prezentace:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{theme\_bw}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-71-1.pdf}

Klasicky vypadající téma s minimem čar je \texttt{theme\_classic()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{theme\_classic}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-72-1.pdf}

Například pro kreslení map oceníte velmi speciální téma \texttt{theme\_void()}, které zahodí všechny čáry:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} \FunctionTok{theme\_void}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-73-1.pdf}

Sbírku předpřipravených témat obsahuje například balík \emph{ggthemes}. Kromě různých \texttt{theme\_*()} obsahuje balík i řadu \texttt{scale\_*\_*()} a několik \texttt{geom\_*()} funkcí.

Například minimalistické téma vytvořené podle Tufteho doporučení obsahuje \texttt{ggthemes::theme\_tufte()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+}\NormalTok{ ggthemes}\SpecialCharTok{::}\FunctionTok{theme\_tufte}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-74-1.pdf}

\hypertarget{modifikace-tuxe9mat}{%
\subsection{Modifikace témat}\label{modifikace-tuxe9mat}}

\emph{ggplot2} umožňuje vytvářet vlastní předpřipravená témata, ale většinou bohatě postačuje použít předpřipravené a upravit ho, to lze zařídit následujícím způsobem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} 
    \FunctionTok{theme\_classic}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{theme}\NormalTok{(}
        \AttributeTok{panel.grid.major =} \FunctionTok{element\_line}\NormalTok{(}\AttributeTok{size =} \FloatTok{0.2}\NormalTok{)}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-75-1.pdf}

U \texttt{theme()} funguje vrstvení stejně, jako u všeho ostatního. Volání jednotlivých funkcí modifikuje podkladovou datovou strukturu. Zavolání funkce \texttt{theme\_classic()} tedy nastaví všechny parametry tak, jak to odpovídá \texttt{theme\_classic} -- to znamená, žádné linky na pozadí. Následné volání \texttt{theme()} přepíše to, co před tím nastavilo volání \texttt{theme\_classic()} a linky přidá. Žádný další parametr nebyl v \texttt{theme()} zadán a proto se nic jiného nezmění.

Pokud by funkce byly volány v opačném pořadí, potom by byl výsledek následující:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} 
    \FunctionTok{theme}\NormalTok{(}
        \AttributeTok{panel.grid.major =} \FunctionTok{element\_line}\NormalTok{(}\AttributeTok{size =} \FloatTok{0.2}\NormalTok{)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{theme\_classic}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-76-1.pdf}

Výsledek by přesně odpovídal \texttt{theme\_classic}. \texttt{theme\_classic()} totiž bez milosti přepíše veškeré formátování vytvořené v předchozích voláních \texttt{theme()} nebo \texttt{theme\_*()}.

Samotné volání \texttt{theme()} ve výše uvedeném příkladu vypadá skutečně velmi krypticky, ale není to tak, protože, podobně jako (skoro) ve všem v \texttt{ggplot2}, za ním stojí promyšlený systém.

Funkce \texttt{theme()} má opravdu mnoho parametrů (viz \texttt{?theme}), jejich jména odpovídají jménům jednotlivých grafických prvků. Jména jsou naštěstí často velmi výstižná, intuitivní, a navíc je RStudio zvládá (u novějších verzí \emph{ggplot2}) našeptávat.

Formátování grafických prvků se ve většině případů provádí pomocí volání jedné z následujících funkcí:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{element\_text}\NormalTok{(}\AttributeTok{family =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{face =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{colour =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{size =} \ConstantTok{NULL}\NormalTok{,}
  \AttributeTok{hjust =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{vjust =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{angle =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{lineheight =} \ConstantTok{NULL}\NormalTok{,}
  \AttributeTok{color =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{margin =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{debug =} \ConstantTok{NULL}\NormalTok{)}

\FunctionTok{element\_line}\NormalTok{(}\AttributeTok{colour =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{size =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{linetype =} \ConstantTok{NULL}\NormalTok{,}
  \AttributeTok{lineend =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{color =} \ConstantTok{NULL}\NormalTok{)}

\FunctionTok{element\_rect}\NormalTok{(}\AttributeTok{fill =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{colour =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{size =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{linetype =} \ConstantTok{NULL}\NormalTok{,}
  \AttributeTok{color =} \ConstantTok{NULL}\NormalTok{)}

\FunctionTok{element\_blank}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

Tu správnou lze uhodnout. Pokud chcete upravit formátování prvku, který je ve své podstatě text, potom chcete použít \texttt{element\_text()}. Příkladem může být modifikace titulku (\texttt{plot.title}) obrázku:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} 
    \FunctionTok{labs}\NormalTok{(}
       \AttributeTok{title =} \StringTok{"Just Another Bar Plot"} 
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{theme}\NormalTok{(}
        \AttributeTok{plot.title =} \FunctionTok{element\_text}\NormalTok{(}\AttributeTok{colour =} \StringTok{"red"}\NormalTok{)}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-78-1.pdf}

Pokud je prvek svým charakterem čára, potom se jeho formátování nastavuje pomocí \texttt{element\_line()} (viz modifikace čar na pozadí výše). Prvky, které jsou ve své podstatě čtyřúhelník se potom modifikují pomocí \texttt{element\_rect()}. Příkladem může být změna barvy pozadí grafu na poníkovou:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} 
    \FunctionTok{theme}\NormalTok{(}
        \AttributeTok{panel.background =} \FunctionTok{element\_rect}\NormalTok{(}\AttributeTok{fill =} \StringTok{"pink"}\NormalTok{)}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-79-1.pdf}

Speciální funkce je potom \texttt{element\_blank()}, která způsobí, že se daný prvek z obrázku kompletně vypustí:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} 
    \FunctionTok{theme}\NormalTok{(}
        \AttributeTok{legend.title =} \FunctionTok{element\_blank}\NormalTok{()}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-80-1.pdf}

Například toto volání vypustilo jméno legendy a to zcela. Špinavé triky typu \texttt{scale\_fill\_discrete(name\ =\ "")} sice způsobí, že jméno ``nebude vidět''. Respektive se vykreslí prázdný řetězec. Místo pro titulek však bude alokováno a bude tak rozhazovat uspořádání obrázku. \texttt{element\_blank()} je správná cesta.

Některé parametry v \texttt{theme()} se nastavují pomocí speciálních funkcí -- typicky jde o nastavení velikostí pomocí funkce \texttt{unit()}. Další parametry se nastavují prostým zadáním hodnoty. Příkladem může být pozice a orientace legendy:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p }\SpecialCharTok{+} 
    \FunctionTok{theme}\NormalTok{(}
        \AttributeTok{legend.position =} \StringTok{"bottom"}\NormalTok{,}
        \AttributeTok{legend.direction =} \StringTok{"horizontal"}
\NormalTok{    )}
\end{Highlighting}
\end{Shaded}

\includegraphics{tidyverse_ggplot2_files/figure-latex/unnamed-chunk-81-1.pdf}

\hypertarget{ukluxe1duxe1nuxed-obruxe1zkux16f}{%
\section{Ukládání obrázků}\label{ukluxe1duxe1nuxed-obruxe1zkux16f}}

Vytvořené obrázky je možné ukládat s použitím funkce \texttt{ggsave()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{ggsave}\NormalTok{(filename, }\AttributeTok{plot =} \FunctionTok{last\_plot}\NormalTok{(), }\AttributeTok{device =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{path =} \ConstantTok{NULL}\NormalTok{,}
  \AttributeTok{scale =} \DecValTok{1}\NormalTok{, }\AttributeTok{width =} \ConstantTok{NA}\NormalTok{, }\AttributeTok{height =} \ConstantTok{NA}\NormalTok{, }\AttributeTok{units =} \FunctionTok{c}\NormalTok{(}\StringTok{"in"}\NormalTok{, }\StringTok{"cm"}\NormalTok{, }\StringTok{"mm"}\NormalTok{),}
  \AttributeTok{dpi =} \DecValTok{300}\NormalTok{, }\AttributeTok{limitsize =} \ConstantTok{TRUE}\NormalTok{, ...)}
\end{Highlighting}
\end{Shaded}

V základním nastavení \texttt{plot\ =\ last\_plot()} funkce \texttt{ggsave()} ukládá poslední vykreslený obrázek. Do parametru \texttt{plot} je však možné přiřadit i obrázek (datovou strukturu) uloženou v proměnné. To je velmi užitečné například při tvorbě obrázků, jejichž vykreslování je velmi náročné -- komplikovaných map, bodových grafů s opravdu velkým počtem pozorování a podobně.

Jméno souboru, do kterého se má obrázek uložit se definuje v parametru \texttt{filename} jako řetězec. \texttt{ggsave()} řetězec analyzuje a podle přípony zvolí exportní formát obrázku. \texttt{ggsave()} umožňuje formáty do vektorových formátů i bitmap:

\begin{itemize}
\tightlist
\item
  vektorové formáty: eps, ps, tex (pictex), pdf, svg a wmf (pouze ve Windows)
\item
  bitmapy: jpeg, tiff, png, bmp
\end{itemize}

Formát (výstupní zařízení) lze zadat přímo pomocí parametru \texttt{device}.

První rozhodnutí je, zda použít vektorový formát nebo bitmapu. Uložení do bitmapy znamená uložení ``fotografie'' obrázku. Takto uložený obrázek může být menší (přesněji nikdy nebude velký) a lze očekávat, že půjde vložit do libovolného dokumentu. Na druhou stranu nepůjde zvětšovat bez různých zkreslení a šumů a výstup nikdy nebude kvalitnější než v případě použití vektorové grafiky.

Vektorové formáty ukládají data, která popisují, kde co na obrázku je. Na rozdíl od bitmap je lze libovolně škálovat bez ztráty kvality a občas přijde vhod i možnost je upravovat (např. posunovat popisky u \texttt{geom\_label()}/\texttt{geom\_text}). Schopnost různých WYSIWYG editorů (např. MS Word atp.) pracovat s vektorovými formáty je navíc omezená a je lepší ji řádně otestovat. Nevýhodou je také jejich velká velikost v případě, že objektů v obrázku je mnoho nebo mají složité tvary.

Příkladem obrázku, u kterého se dramaticky liší velikost podle použitého formátu je následující mapa ČR s katastrálními územími obcí. Zobrazená bitmapa (png) má přibližně 0,1 MB. Stejná mapa ve vektorovém formátu má téměř 11,6 MB.

\begin{figure}
\centering
\includegraphics{figs/ggplot2/test_plot.png}
\caption{Mapa ČR s katastrálními územími obcí}
\end{figure}

Další parametry \texttt{ggsave()} umožňují přesné nastavení výstupu co do rozměrů a rozlišení (pouze pro bitmapy). Při vhodném nastavení těchto parametrů vzhledem k výsledné publikaci lze dosáhnout dobrých výsledků i při používání bitmap. Ve většině případů je však doporučeníhodné používání vektorových formátů.

\hypertarget{co-dux11blat-a-co-nedux11blat}{%
\section{Co dělat a co nedělat}\label{co-dux11blat-a-co-nedux11blat}}

\emph{ggplot2} a jeho rozšíření nabízí ohromnou škálu možností. Před tím než začnete kreslit je dobré se rozmyslet, zda je vůbec rozumné kreslit. Často je užitečnější a pro čtenáře srozumitelnější prezentovat data v podobě tabulky -- a to zejména pokud je jich málo. Pokud se rozhodnete kreslit, potom se vždy musíte snažit, aby obrázek čtenáři srozumitelně komunikoval nezkreslenou informaci.

Tufte (2001) formuluje jednoduché doporučení, které byste měli mít vždy v paměti:

\emph{Graphical excellence is that which gives to the viewer the greatest number of ideas in the shortest time with the least ink in the smallest space.}

\hypertarget{part-statistickuxe9-metody-v-r}{%
\part{Statistické metody v R}\label{part-statistickuxe9-metody-v-r}}

\hypertarget{kap:ekonometrie}{%
\chapter{Ekonometrie v R}\label{kap:ekonometrie}}

Skupina balíků sdružená v \texttt{tidyverse} představuje kompaktní sadu nástrojů pro práci s daty. Sdílejí datové struktury (tabulky v tidy formátu) i logiku ovládání. Bohužel podobná unifikace chybí u nástrojů, které výzkumník potřebuje pro ekonometrickou (statistickou) analýzu dat, která následuje po zpracování dat. Ekonometrické nástroje jsou v R rozptýleny v mnoha balících různé kvality, které nejsou žádným způsobem koordinovány nebo unifikovány. To velmi znepříjemňuje ekonometrickou analýzu dat v R. I přesto R poskytuje všechny základní a mnoho pokročilých nástrojů a v zásadě pokrývá všechny běžné potřeby výzkumníků.

Účelem této kapitoly není vysvětlovat teorii ekonometrické analýzy nebo diskutovat vhodnost nasazení jednotlivých metod nebo designu regresní analýzy (identifikační strategie), ale seznámit čtenáře se základní logikou fungování ekonometrických nástrojů v R. Právě základní logika fungování je totiž něco, co drtivá většina ekonometrických nástrojů v R sdílí. Tuto základní logiku lze popsat pomocí obrázku XXX:

Na počátku ekonometrické analýzy má výzkumník data a představu o tom, jak svět funguje (o data generujícím procesu). Pro naprostou většinu ekonometrických nástrojů (a všechny základní) je vhodné připravit si data do podoby tabulky v tidy formátu. Představa o fungování světa (tj. o vztazích mezi proměnnými v datové tabulce) se formalizuje do podoby modelu. Jeho podoba se předává R v podobě speciální datové třídy \texttt{formula}.

Data a specifikovaný model jsou nezbytnými vstupy pro estimátor. Estimátor je typicky funkce, která provede odhad parametrů modelu a vytvoří výstupní objekt. Tento objekt obsahuje typicky pouze samotný odhad parametrů modelu, tabulku dat použitých pro odhad, rezidua, vyrovnané hodnoty a další doplňující údaje. Typicky neobsahuje žádné testy, robustní směrodatné chyby a podobně. Analýza a zobrazení odhadu (výsledků) se v R typicky provádí pomocí specializovaných funkcí, pro které je výstup estimační funkce vstupem.

V této kapitole se naučíte:

\begin{itemize}
\tightlist
\item
  Specifikovat model ve třídě \texttt{formula}
\item
  Použít základní estimační funkce
\item
  Provést základní diagnostické testy odhadu
\item
  Vypočítat robustní směrodatné chyby
\item
  Provádět hromadně odhady více modelových specifikací na stejném vzorku dat
\item
  Provádět hromadně odhady jedné modelové specifikace na různých vzorcích dat
\item
  Exportovat výsledky do přehledných tabulek
\end{itemize}

\hypertarget{r-a-ostatnuxed}{%
\section{R a ostatní}\label{r-a-ostatnuxed}}

R představuje spolu s Pythonem špičkový software ohledně práce s daty. Tomu odpovídá i to, že právě tyto dva jazyky jsou mezi datovými analytiky pravděpodobně nejvíce používané. Pozice R ohledně ekonometrické analýzy však zdaleka není tak jasná. V ekonomii se rozhodně nejedná o nejpoužívanější nástroj. Tím je stále bezesporu Stata, která se logikou svého fungování velmi podobá Gretlu. (Gretl je navržen podle Stata.) Stata pracuje nad jednou tabulkou dat, která je nahraná v paměti. V rámci každého odhadu specifikujete například i typ robustních chyb, které chcete použít. Své rozhodnutí však později nemůžete změnit. Výsledkem takového návrhu je velmi obtížná práce s daty ve Stata (např. slučování dvou tabulek). Nutnost specifikovat všechny parametry již v rámci odhadu modelu může být také velmi omezující v případě odhadů, které jsou časově náročné. Stata také dává oproti R výzkumníkovi často menší svobodu v detailním nastavení jednotlivých procedur. V neposlední řadě je Stata také velmi nákladná (levné verze jsou omezené tak, že nejsou v reálném boji použitelné). Omezené možnosti jsou ovšem lehce vyvažovány jednoduchostí ovládání. Hlavní výhodou Stata je však implementace obrovského množství nejrůznějších estimátorů, které mají velmi konzistentní rozhraní.

\hypertarget{specifikace-modelu-pomocuxed-formula}{%
\section{\texorpdfstring{Specifikace modelu pomocí \texttt{formula}}{Specifikace modelu pomocí formula}}\label{specifikace-modelu-pomocuxed-formula}}

Fungování ekonometrických nástrojů můžeme ilustrovat na příkladu datasetu s výškou, váhou, věkem, sportem, a pohlavím sportovců, kteří se zúčastnili olympijských her v Londýně v roce 2012 (dostupný v \texttt{VGAMdata::oly12}):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{VGAMdata}\SpecialCharTok{::}\NormalTok{oly12 }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{mutate}\NormalTok{(}
    \AttributeTok{Sport =} \FunctionTok{str\_extract}\NormalTok{(Sport, }\StringTok{"[:alnum:]*"}\NormalTok{)}
\NormalTok{  ) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{select}\NormalTok{(}
\NormalTok{    Height, Weight, Sex, Age, Sport}
\NormalTok{  ) }\SpecialCharTok{\%\textgreater{}\%} 
\NormalTok{  as\_tibble }\SpecialCharTok{\%\textgreater{}\%}
  \FunctionTok{drop\_na}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{mutate\_if}\NormalTok{(is.factor,as.character) }\OtherTok{{-}\textgreater{}}\NormalTok{ oly12}

\FunctionTok{print}\NormalTok{(oly12, }\AttributeTok{n=}\DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 9,038 x 5
##   Height Weight Sex     Age Sport    
##    <dbl>  <int> <chr> <int> <chr>    
## 1   1.7      60 M        23 Judo     
## 2   1.93    125 M        33 Athletics
## 3   1.87     76 M        30 Athletics
## 4   1.78     85 F        26 Athletics
## 5   1.82     80 M        27 Handball 
## # ... with 9,033 more rows
\end{verbatim}

Nejprve nás bude zajímat vztah mezi váhou a výškou sportovců. Ten si můžeme vykreslit pomocí jednoduchého bodového grafu:

\includegraphics{econometrics_files/figure-latex/unnamed-chunk-5-1.pdf}

Zdá se, že existuje lineární vztah mezi váhou a výškou sportovců, který můžeme popsat rovnicí:
\[Weight = \alpha + \beta Height + \varepsilon\]
kde \(\alpha\) a \(\beta\) jsou neznámé parametry, které chceme odhadnout a \(\varepsilon\) je náhodná složka.

Tuto rovnici si můžeme představit jako přímku, která je proložena mrakem pozorování:

\begin{verbatim}
## `geom_smooth()` using formula 'y ~ x'
\end{verbatim}

\includegraphics{econometrics_files/figure-latex/unnamed-chunk-6-1.pdf}

Rovnici však musíme zapsat tak, aby byla srozumitelná i pro R. K tomu slouží objekty třídy \texttt{formula}. Jejich formulace následuje syntax:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{LHS }\SpecialCharTok{\textasciitilde{}}\NormalTok{ RHS}
\end{Highlighting}
\end{Shaded}

Tedy výrazy na levé straně (LHS) \(=\) (zastoupené znakem \texttt{\textasciitilde{}}) výrazy na pravé straně (RHS). Rovnici vysvětlující váhu bychom tedy mohli popsat jako:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height}
\FunctionTok{class}\NormalTok{(model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "formula"
\end{verbatim}

V ekonomii je závislá (vysvětlovaná) proměnná (tedy proměnná na levé straně rovnice) funkcí více než jedné nezávislé (vysvětlující) proměnné. Pokud bychom chtěli vysvětlovat váhu nejen výškou, ale i věkem, potom bychom rozšířili specifikaci následujícím způsobem:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height }\SpecialCharTok{+}\NormalTok{ Age}
\end{Highlighting}
\end{Shaded}

Dodatečná proměnné jsou přidávány pomocí \texttt{+}.

Za povšimnutí stojí, že při použití takovéto specifikace by byl model odhadnut s úrovňovou konstantou \(\alpha\) -- i když není explicitně v rovnici přítomna. Explicitně se naopak musí zadat její nepřítomnost připojením \texttt{-1} nebo \texttt{0}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height }\SpecialCharTok{{-}} \DecValTok{1}
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height }\SpecialCharTok{+} \DecValTok{0}
\end{Highlighting}
\end{Shaded}

Jména proměnných v rovnici musí odpovídat jménům sloupců v datové tabulce. Zásadní výhodou R je, že do rovnice je možné zadat i transformace dat:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}} \FunctionTok{log}\NormalTok{(Height)}
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height }\SpecialCharTok{\textgreater{}=} \FloatTok{1.8}
\end{Highlighting}
\end{Shaded}

První varianta například odpovídá specifikaci:

\[Weight = \alpha + \beta \log(Height) + \varepsilon\]

Ve druhé je váha vysvětlována dummy (umělou proměnnou). Výraz \texttt{Height\ \textgreater{}=\ 1.8} vytvoří logickou proměnnou, která je při volání estimační funkce transformována na vektor s hodnotami 1 a 0.

\textbf{Není tedy potřeba vytvářet nové transformované sloupce v datové tabulce.} To je velký rozdíl mezi R a Statou, Gretlem,\ldots{} (Jakkoliv je v některých případech vytvoření transformovaných proměnných do tabulky doporučeníhodné.)

V rovnici může být přímo přítomna celá řada funkcí -- s výjimkou těch, jejichž interpretace by nebyla jasná. Pokud bychom například chtěli odhadnout modelovou specifikaci

\[Weight = \alpha + \beta (Height + Age) + \varepsilon\]

potom je nutná sdělit R, že má nejdříve sečíst \texttt{Height} a \texttt{Age} a pro vysvětlení \texttt{Weight} použít až výsledný součet. Pro tyto účely se používá funkce \texttt{I()}. Ta sděluje, že se mají nejprve provést operace definované uvnitř funkce a pro odhad použít až výsledek.

Výše uvedený příklad by se tak R tlumočil jako

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}} \FunctionTok{I}\NormalTok{(Height }\SpecialCharTok{+}\NormalTok{ Age)}
\end{Highlighting}
\end{Shaded}

Třída formula umožňuje jednoduše jednoduše definovat i interakční členy pomocí operátorů dvojtečka (\texttt{:}) a hvězdička (\texttt{*}):

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height}\SpecialCharTok{:}\NormalTok{Sex}
\end{Highlighting}
\end{Shaded}

Chápe R jako

\[Weight = \alpha + \beta Height\times Sex_{male} + \gamma Height\times Sex_{female} + \varepsilon\]
Tato rovnice vyjadřuje možný odlišný mezní efekt výšky na váhu u mužů a žen. Výsledné proložení mrakem pozorování by se tak v bodovém grafu výše vlastně rozpadlo na dvě přímky s odlišným sklonem (parametry \(\beta\) a \(\gamma\)) a shodnou úrovňovou konstantou \(\alpha\).

Další možností jak popsat interakci proměnných je \texttt{*}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height}\SpecialCharTok{*}\NormalTok{Sex}
\end{Highlighting}
\end{Shaded}

Tato \texttt{formula} odpovídá jiné rovnici:

\[Weight = \alpha + \beta Height  + \epsilon Sex_{male} + \gamma Height\times Sex_{male} + \varepsilon\]
Tato specifikace umožňuje odlišnost regresní křivky pro muže a ženy jak ve sklonu, tak v úrovňové konstantě.

Zvláštní význam má i symbol stříšky (\texttt{\^{}}). Rovnici

\[Weight = \alpha + \beta_1 Height  + \beta_2 Age + \beta_3 Sex_{male} + \gamma_1 Height\times Sex_{male} + \gamma_2 Height\times Age + \gamma_3 Sex_{male}\times Age + \varepsilon\]
můžeme zapsat jako:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ (Height }\SpecialCharTok{+}\NormalTok{ Age }\SpecialCharTok{+}\NormalTok{ Sex)}\SpecialCharTok{\^{}}\DecValTok{2}
\end{Highlighting}
\end{Shaded}

Výraz se přeloží tak, že výsledná rovnice obsahuje jednotlivé proměnné a také jejich interakce do, v tomto případě, druhého řádu.

Pro třídu formula jsou implementovány i některé zajímavé metody. Velmi užitečná je například funkce \texttt{update()} s velmi prostou syntaxí:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{update}\NormalTok{(old,new,...)}
\end{Highlighting}
\end{Shaded}

Kde \texttt{old} je původní rovnice a \texttt{new} pravidla, která stanovují, jak se původní rovnice má upravit.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height }\SpecialCharTok{+}\NormalTok{ Age}
\FunctionTok{print}\NormalTok{(model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Weight ~ Height + Age
\end{verbatim}

Takto můžeme zachovat všechny proměnné -- reprezentované pomocí \texttt{.} a jen některou přidat nebo odebrat:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{update}\NormalTok{(. }\SpecialCharTok{\textasciitilde{}}\NormalTok{ . }\SpecialCharTok{{-}}\NormalTok{Age)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Weight ~ Height
\end{verbatim}

Nebo je možné nahradit celou stranu rovnice:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{update}\NormalTok{(. }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Age)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Weight ~ Age
\end{verbatim}

\hypertarget{odhad-modelu}{%
\section{Odhad modelu}\label{odhad-modelu}}

Při volání estimační funkce se dohromady spojí všechny tři komponenty: modelová specifikace, data a estimátor.

Základní estimační funkcí je \texttt{lm()}, určená pro odhad lineárních modelů. Funkce přijímá celou řadu parametrů:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{lm}\NormalTok{(formula, data, subset, weights, na.action, }\AttributeTok{method =} \StringTok{"qr"}\NormalTok{, }
    \AttributeTok{model =} \ConstantTok{TRUE}\NormalTok{, }\AttributeTok{x =} \ConstantTok{FALSE}\NormalTok{, }\AttributeTok{y =} \ConstantTok{FALSE}\NormalTok{, }\AttributeTok{qr =} \ConstantTok{TRUE}\NormalTok{, }\AttributeTok{singular.ok =} \ConstantTok{TRUE}\NormalTok{, }
    \AttributeTok{contrasts =} \ConstantTok{NULL}\NormalTok{, offset, ...) }
\end{Highlighting}
\end{Shaded}

Mezi základní patří:

\begin{itemize}
\tightlist
\item
  \texttt{formula} je objekt třídy ``formula'', který obsahuje symbolický popis rovnice, jejíž parametry se mají odhadnout.
\item
  \texttt{data} je tabulka (\texttt{data.frame}) která obsahuje data, která se mají použít. Jména sloupců v tabulce musí odpovídat proměnným použitým v parametru \texttt{formula}. Datová tabulka nemusí být specifikována. Pokud je tento parametr prázdný, potom R interpretuje jména v modelu jako jména proměnných z prostředí, ze kterého je funkce \texttt{lm()} volána.
\item
  \texttt{subset} je nepovinný parametr, který určuje, které pozorování (řádky) se mají použít pro odhad
\item
  \texttt{weights} je vektor vah. Pokud není zadán je pro odhad použit obyčejný OLS estimátor, ve kterém mají všechna pozorování stejnou váhu. V případě zadání vah je vráceno WLS.
\end{itemize}

Struktura a forma těchto základních vstupů je typicky shodná právě s \texttt{lm()}.

\hypertarget{vytvoux159enuxed-matice-pluxe1nu}{%
\subsection{Vytvoření matice plánu}\label{vytvoux159enuxed-matice-pluxe1nu}}

Pro odhad použijeme model v následující specifikaci:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{model }\OtherTok{\textless{}{-}}\NormalTok{ Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height }\SpecialCharTok{+}\NormalTok{ Age }\SpecialCharTok{+} \FunctionTok{I}\NormalTok{(Age}\SpecialCharTok{\^{}}\DecValTok{2}\NormalTok{) }\SpecialCharTok{+}\NormalTok{ Sex}
\end{Highlighting}
\end{Shaded}

Proměnné \texttt{Weight}, \texttt{Height} a \texttt{Age} jsou numerické spojité proměnné. Proměnná \texttt{Sex} je zcela jiný případ. Jsou to kategoriální proměnná, se dvěma úrovněmi (\texttt{M} -- muž, \texttt{F} -- žena). Taková proměnná nemůže vstoupit do regrese přímo. Je nutné ji transformovat na matici nul a jedniček. Transformovaná matice bude mít vždy o jeden sloupec méně, než kolik má transformovaná proměnná úrovní.

Estimační funkce si všechny vstupní faktory transformuje sama pomocí interního volání funkce \texttt{model.matrix()}. V rámci volání tento funkce se provedou i požadované transformace dat. V případě našeho modelu vytvoření druhé mocniny věku. Výsledkem volání \texttt{model.matrix()} je tedy matice plánu:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{model.matrix}\NormalTok{(model, }\AttributeTok{data =}\NormalTok{ oly12) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{head}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   (Intercept) Height Age I(Age^2) SexM
## 1           1   1.70  23      529    1
## 2           1   1.93  33     1089    1
## 3           1   1.87  30      900    1
## 4           1   1.78  26      676    0
## 5           1   1.82  27      729    1
## 6           1   1.82  30      900    0
\end{verbatim}

Funkce \texttt{model.matrix()} provede požadované transformace numerických proměnných (přidán sloupec \texttt{I(Age\^{}2)}) a pokud najde jinou než numerickou proměnnou (\texttt{factor}) provede jejich transformaci do matice binárních proměnných. Při této transformaci postupuje následovně. Prohlédne si faktor a určí referenční úroveň (\emph{level}). Ta nebude ve výsledné matici obsažena, pokud by byla, model by nešel odhadnout. Pro každou zbývající úroveň vytvoří vektor, který nabývá hodnoty 1 pro pozorování s danou úrovní faktoru. V příkladu výše si \texttt{model.frame()} vybral jako referenční úroveň hodnotu \texttt{F} a vytvořil vektor \texttt{SexM}, který nabývá hodnoty 1 pro muže a 0 ve všech ostatních případech.

Pokud by byla vstupní kategoriální proměnná třídy \texttt{character}, potom by ji \texttt{model.frame()}nejprve transformoval na \texttt{factor} a pokračoval tak, jak je popsáno výše. Toto chování může být motivem pro to, aby uživatel sám provedl konverzi na faktor. Třída faktor totiž umožňuje nastavit, která úroveň má být použita jako referenční. Toho můžeme docílit pomocí několika cest.

První variantou je konverze do \texttt{factor} s pomocí \texttt{base::factor()}. Tato funkce umožňuje uživateli zadat vektor možných úrovní. První z nich se potom nastaví jako referenční:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{factor}\NormalTok{(Sex}\SpecialCharTok{$}\NormalTok{oly12, }\FunctionTok{c}\NormalTok{(}\StringTok{"M"}\NormalTok{,}\StringTok{"F"}\NormalTok{))}
\end{Highlighting}
\end{Shaded}

Tento postup lze aplikovat i na proměnné, které již jsou \texttt{factor}. Nevýhodou je nutnost zadávat všechny úrovně. Podobnou variantou je použití funkce \texttt{forcats::as\_factor()}. Ta má vlastnost, že pořadí úrovní stanoví podle podle pořadí jejich výskytu v transformovaném vektoru. Problém této funkce je, že pracuje zvláštně s chybějícími hodnotami. (To se pravděpodobně bude během vývoje balíku ještě měnit.)

Další principiálně odlišnou variantou je nastavení referenční úrovně pomocí funkce \texttt{stats::relevel()} (alternativně \texttt{forcats::fct\_relevel()}). Ta umožňuje prosté nastavení referenční úrovně:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{factor}\NormalTok{(Sex}\SpecialCharTok{$}\NormalTok{oly12) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{relevel}\NormalTok{(}\StringTok{"M"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Po změně referenční úrovně bude výsledek následující:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{oly12 }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{mutate}\NormalTok{(}
    \AttributeTok{Sex =} \FunctionTok{factor}\NormalTok{(Sex) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{relevel}\NormalTok{(}\StringTok{"M"}\NormalTok{)}
\NormalTok{  ) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{model.matrix}\NormalTok{(model,.) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{head}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   (Intercept) Height Age I(Age^2) SexF
## 1           1   1.70  23      529    0
## 2           1   1.93  33     1089    0
## 3           1   1.87  30      900    0
## 4           1   1.78  26      676    1
## 5           1   1.82  27      729    0
## 6           1   1.82  30      900    1
\end{verbatim}

Zejména v rámci průzkumu dat je zajímavá varianta provést konverzi na faktor v rámci modelu (\texttt{formula}) -- všimněte si, že může být aplikována i na numerickou proměnnou:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{Weight }\SpecialCharTok{\textasciitilde{}}\NormalTok{ Height }\SpecialCharTok{+} \FunctionTok{factor}\NormalTok{(Age) }\SpecialCharTok{+}\NormalTok{ Sex}
\end{Highlighting}
\end{Shaded}

Konverze numerických hodnot do faktoru je poměrně častá zvláště u dotazníkových dat, kde čísla mohou pouze kódovat hodnoty kategoriální proměnné. Dalším případem je například vytvoření fixních efektů pro roky.

Funkce \texttt{model.matrix()}, kterou si estimační funkce volá interně tedy vytvoří matici plánu, která je následně použité při samotném odhadu parametrů modelu. Odhadová procedura si liší podle použité estimační funkce. V případě \texttt{lm()} je to QR dekompozice (\url{https://en.wikipedia.org/wiki/QR_decomposition}), při použití \texttt{glm()} jsou to například různé numerické optimalizační algoritmy (defaultně IWLS:\url{https://en.wikipedia.org/wiki/Iteratively_reweighted_least_squares}).

\hypertarget{vuxfdstupy-estimaux10dnuxed-funkce}{%
\subsection{Výstupy estimační funkce}\label{vuxfdstupy-estimaux10dnuxed-funkce}}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{lm}\NormalTok{(model, }\AttributeTok{data =}\NormalTok{ oly12) }\OtherTok{{-}\textgreater{}}\NormalTok{ est\_model}

\FunctionTok{class}\NormalTok{(est\_model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "lm"
\end{verbatim}

Funkce \texttt{lm()} vrací S3 objekt třídy \texttt{lm}. Jiné estimační funkce vrací jiné objekty, které jsou ovšem často potomky \texttt{lm}. Objekt třídy \texttt{lm} má následující strukturu (viz \texttt{?lm}):

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{str}\NormalTok{(est\_model, }\AttributeTok{max.level =} \DecValTok{1}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## List of 13
##  $ coefficients : Named num [1:5] -1.06e+02 9.46e+01 4.10e-01 -4.09e-03 5.59
##   ..- attr(*, "names")= chr [1:5] "(Intercept)" "Height" "Age" "I(Age^2)" ...
##  $ residuals    : Named num [1:9038] -7.71 33.72 -9.15 14.68 0.11 ...
##   ..- attr(*, "names")= chr [1:9038] "1" "2" "3" "4" ...
##  $ effects      : Named num [1:9038] -6926.6 -1161.4 -96.3 -15.7 -221.1 ...
##   ..- attr(*, "names")= chr [1:9038] "(Intercept)" "Height" "Age" "I(Age^2)" ...
##  $ rank         : int 5
##  $ fitted.values: Named num [1:9038] 67.7 91.3 85.2 70.3 79.9 ...
##   ..- attr(*, "names")= chr [1:9038] "1" "2" "3" "4" ...
##  $ assign       : int [1:5] 0 1 2 3 4
##  $ qr           :List of 5
##   ..- attr(*, "class")= chr "qr"
##  $ df.residual  : int 9033
##  $ contrasts    :List of 1
##  $ xlevels      :List of 1
##  $ call         : language lm(formula = model, data = oly12)
##  $ terms        :Classes 'terms', 'formula'  language Weight ~ Height + Age + I(Age^2) + Sex
##   .. ..- attr(*, "variables")= language list(Weight, Height, Age, I(Age^2), Sex)
##   .. ..- attr(*, "factors")= int [1:5, 1:4] 0 1 0 0 0 0 0 1 0 0 ...
##   .. .. ..- attr(*, "dimnames")=List of 2
##   .. ..- attr(*, "term.labels")= chr [1:4] "Height" "Age" "I(Age^2)" "Sex"
##   .. ..- attr(*, "order")= int [1:4] 1 1 1 1
##   .. ..- attr(*, "intercept")= int 1
##   .. ..- attr(*, "response")= int 1
##   .. ..- attr(*, ".Environment")=<environment: R_GlobalEnv> 
##   .. ..- attr(*, "predvars")= language list(Weight, Height, Age, I(Age^2), Sex)
##   .. ..- attr(*, "dataClasses")= Named chr [1:5] "numeric" "numeric" "numeric" "numeric" ...
##   .. .. ..- attr(*, "names")= chr [1:5] "Weight" "Height" "Age" "I(Age^2)" ...
##  $ model        :'data.frame':   9038 obs. of  5 variables:
##   ..- attr(*, "terms")=Classes 'terms', 'formula'  language Weight ~ Height + Age + I(Age^2) + Sex
##   .. .. ..- attr(*, "variables")= language list(Weight, Height, Age, I(Age^2), Sex)
##   .. .. ..- attr(*, "factors")= int [1:5, 1:4] 0 1 0 0 0 0 0 1 0 0 ...
##   .. .. .. ..- attr(*, "dimnames")=List of 2
##   .. .. ..- attr(*, "term.labels")= chr [1:4] "Height" "Age" "I(Age^2)" "Sex"
##   .. .. ..- attr(*, "order")= int [1:4] 1 1 1 1
##   .. .. ..- attr(*, "intercept")= int 1
##   .. .. ..- attr(*, "response")= int 1
##   .. .. ..- attr(*, ".Environment")=<environment: R_GlobalEnv> 
##   .. .. ..- attr(*, "predvars")= language list(Weight, Height, Age, I(Age^2), Sex)
##   .. .. ..- attr(*, "dataClasses")= Named chr [1:5] "numeric" "numeric" "numeric" "numeric" ...
##   .. .. .. ..- attr(*, "names")= chr [1:5] "Weight" "Height" "Age" "I(Age^2)" ...
##  - attr(*, "class")= chr "lm"
\end{verbatim}

Důležité jsou zejména následující položky:

\begin{itemize}
\tightlist
\item
  \texttt{coefficients}\ldots pojmenovaný vektor odhadnutých koeficientů
\end{itemize}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{est\_model}\SpecialCharTok{$}\NormalTok{coefficients}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##   (Intercept)        Height           Age      I(Age^2)          SexM 
## -1.060127e+02  9.463456e+01  4.096565e-01 -4.094392e-03  5.591553e+00
\end{verbatim}

\begin{itemize}
\tightlist
\item
  \texttt{residuals}\ldots vektor reziduí -- tj. odhadů náhodné složky \(\varepsilon\)
\end{itemize}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{est\_model}\SpecialCharTok{$}\NormalTok{residuals }\SpecialCharTok{\%\textgreater{}\%}\NormalTok{ head}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##          1          2          3          4          5          6 
## -7.7137568 33.7165890 -9.1502080 14.6799373  0.1103484 -1.8269273
\end{verbatim}

\begin{itemize}
\tightlist
\item
  \texttt{fitted.values}\ldots vyrovnané hodnoty
\end{itemize}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{est\_model}\SpecialCharTok{$}\NormalTok{fitted.values }\SpecialCharTok{\%\textgreater{}\%}\NormalTok{ head}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##        1        2        3        4        5        6 
## 67.71376 91.28341 85.15021 70.32006 79.88965 74.82693
\end{verbatim}

\begin{itemize}
\tightlist
\item
  \texttt{model}\ldots modifikovanou tabulku dat, která byla skutečně použita při odhadu (tj, například s vypuštěnými nepoužitými proměnnými nebo neúplnými řádky).
\end{itemize}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{est\_model}\SpecialCharTok{$}\NormalTok{fitted.values }\SpecialCharTok{\%\textgreater{}\%}\NormalTok{ head}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##        1        2        3        4        5        6 
## 67.71376 91.28341 85.15021 70.32006 79.88965 74.82693
\end{verbatim}

Za povšimnutí stojí, že objekt obsahuje skutečně pouze odhad -- data, odhadnuté koeficienty, rezidua, vyrovnané hodnoty a dodatečné informace. Neobsahuje žádné dodatečné výpočty jako například diagnostické testy.

Pro objekty třídy \texttt{lm} existuje metoda generické funkce \texttt{print()}. Její výstupy však nejsou nijak zvlášť informativní:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(est\_model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
## Call:
## lm(formula = model, data = oly12)
## 
## Coefficients:
## (Intercept)       Height          Age     I(Age^2)         SexM  
##  -1.060e+02    9.463e+01    4.097e-01   -4.094e-03    5.592e+00
\end{verbatim}

Obsahuje jen použité volání a odhadnuté hodnoty koeficientů. Více se dozvíme pomocí funkce \texttt{summary()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{summary}\NormalTok{(est\_model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
## Call:
## lm(formula = model, data = oly12)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -56.334  -5.717  -1.336   3.756 135.665 
## 
## Coefficients:
##               Estimate Std. Error t value Pr(>|t|)    
## (Intercept) -1.060e+02  2.385e+00 -44.444  < 2e-16 ***
## Height       9.463e+01  1.141e+00  82.918  < 2e-16 ***
## Age          4.097e-01  1.096e-01   3.738 0.000187 ***
## I(Age^2)    -4.094e-03  1.819e-03  -2.250 0.024442 *  
## SexM         5.592e+00  2.560e-01  21.840  < 2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 10.13 on 9033 degrees of freedom
## Multiple R-squared:  0.6031, Adjusted R-squared:  0.6029 
## F-statistic:  3431 on 4 and 9033 DF,  p-value: < 2.2e-16
\end{verbatim}

V tomto případě vidíme kromě odhadů koeficientů i směrodatné chyby a výsledky testů statistické významnosti koeficientů (v tomto případě t-testů). Výstup je také doplněn několika dalšími údaji jako je výsledek F-testu a (adjustovaný) koeficient determinace. Funkce \texttt{summary()} poskytuje rychlý pohled na výsledky, nicméně ten může být zavádějící. Funkce totiž vrací pouze standardní výstupy. Nijak například nereflektuje možné zkreslení odhadu směrodatných odchylek kvůli heteroskedasticitě a podobně. Všimněte si, že \texttt{summary()} používá méně obvyklé -- a přísnější -- hvězdičkové značení!

\hypertarget{pruxe1ce-s-vuxfdsledkem-odhadux16f}{%
\subsection{Práce s výsledkem odhadů}\label{pruxe1ce-s-vuxfdsledkem-odhadux16f}}

V R najdete řadu specializovaných funkcí, které dokážou z výsledného modelu získávat, nebo na jeho základě dopočítávat užitečné informace. Tabulka obsahuje jejich základní přehled:

\begin{longtable}[]{@{}
  >{\raggedright\arraybackslash}p{(\columnwidth - 2\tabcolsep) * \real{0.24}}
  >{\raggedright\arraybackslash}p{(\columnwidth - 2\tabcolsep) * \real{0.76}}@{}}
\toprule
Funkce & Popis \\
\midrule
\endhead
\texttt{coefficients()}, \texttt{coefs()} & Vrací odhadnuté koeficienty -- obsah \texttt{.\$coefficients} \\
\texttt{residuals()}, \texttt{resid()} & Vrací vektor reziduí -- pro objekty \texttt{lm} je výstup identický s \texttt{.\$residuals} \\
\texttt{fitted.values()} & Vrací očekávané hodnoty -- obsah \texttt{.\$fitted.values} \\
\texttt{predict()} & Umožňuje dopočítat predikce pro jiná data, než na kterých byl model odhadnut \\
\texttt{plot()} & Vrací diagnostické grafy vytvořené pomocí základní grafiky (ne v \texttt{ggplot2}) \\
\texttt{confint()} & Vrací konfidenční intervaly pro odhady koeficientů \\
\texttt{deviance()} & Vrací MSE -- průměr čtverců reziduí \\
\texttt{vcov()} & Vrací odhad kovarianční matice \\
\texttt{logLik()} & Vrací log-likelihood \\
\texttt{AIC()} & Vrací Akaikovo informační krítérium (AIC) \\
\texttt{BIC()} & Vrací Schwarzovo Bayesian kritérium (BIC) \\
\texttt{nobs()} & Vrací počet pozorování \\
\bottomrule
\end{longtable}

Pro některé účely je vhodné seznámit se i se sofistikovanějšími funkcemi. Pro účely diagnostiky nebo okometrického posouzení kvality vyrovnání může být užitečné výsledky odhadu vizualizovat. Výsledky jsou však schované ve zvláštním objektu a ne v tabulce, kterou potřebujeme pro použití s \texttt{ggplot2}. Pro transformaci různých objektů do tabulky existuje v \texttt{ggplot2} funkce \texttt{fortify()}. Stejnou funkcionalitu poskytuje i balík \textbf{broom}. Pro objekty třídy \texttt{lm} je ekvivalentem funkce \texttt{broom::augment()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(broom)}
\FunctionTok{augment}\NormalTok{(est\_model) }\SpecialCharTok{\%\textgreater{}\%}\NormalTok{ as\_tibble }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{print}\NormalTok{(}\AttributeTok{n =} \DecValTok{5}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 9,038 x 11
##   Weight Height   Age `I(Age^2)` Sex   .fitted .resid     .hat .sigma    .cooksd
##    <int>  <dbl> <int>   <I<dbl>> <chr>   <dbl>  <dbl>    <dbl>  <dbl>      <dbl>
## 1     60   1.7     23        529 M        67.7 -7.71  0.000453   10.1    5.26e-5
## 2    125   1.93    33       1089 M        91.3 33.7   0.000474   10.1    1.05e-3
## 3     76   1.87    30        900 M        85.2 -9.15  0.000299   10.1    4.89e-5
## 4     85   1.78    26        676 F        70.3 14.7   0.000336   10.1    1.41e-4
## 5     80   1.82    27        729 M        79.9  0.110 0.000235   10.1    5.58e-9
## # ... with 9,033 more rows, and 1 more variable: .std.resid <dbl>
\end{verbatim}

Pozor, \textbf{broom} navrací \texttt{tibble}. Proto je užitečné výstup do \texttt{tibble} konvertovat. Výsledek je již jednoduše použitelný pro vizualizaci pomocí \texttt{ggplot2}. Následující obrázek ukazuje korelaci pozorovaných (\emph{observed}) a vyrovnaných (\emph{fitted}) hodnot. Do obrázku je přidána pomocí \texttt{geom\_abline()} i osa kvadrantu na která se pozorované a vyrovnané hodnoty rovnají.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{est\_model }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{augment}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{ggplot}\NormalTok{(}
    \FunctionTok{aes}\NormalTok{(}\AttributeTok{x =}\NormalTok{ Weight, }\AttributeTok{y =}\NormalTok{ .fitted)}
\NormalTok{  ) }\SpecialCharTok{+}
  \FunctionTok{geom\_point}\NormalTok{(}\AttributeTok{alpha =} \FloatTok{0.05}\NormalTok{) }\SpecialCharTok{+}
  \FunctionTok{geom\_abline}\NormalTok{(}\AttributeTok{slope =} \DecValTok{1}\NormalTok{, }\AttributeTok{intercept =} \DecValTok{0}\NormalTok{, }\AttributeTok{color =} \StringTok{"red"}\NormalTok{) }\SpecialCharTok{+}
  \FunctionTok{scale\_x\_continuous}\NormalTok{(}\AttributeTok{name =} \StringTok{"Observed values"}\NormalTok{) }\SpecialCharTok{+}
  \FunctionTok{scale\_y\_continuous}\NormalTok{(}\AttributeTok{name =} \StringTok{"Fitted values"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{econometrics_files/figure-latex/unnamed-chunk-36-1.pdf}

Balík \textbf{broom} obsahuje i další užitečné funkce: \texttt{tidy()} a \texttt{glance()}. Funkce \texttt{tidy()} vrací tabulku s odhady parametrů, směrodatných odchylek, testových statistik a p-hodnot:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{tidy}\NormalTok{(est\_model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 5
##   term          estimate std.error statistic   p.value
##   <chr>            <dbl>     <dbl>     <dbl>     <dbl>
## 1 (Intercept) -106.        2.39       -44.4  0        
## 2 Height        94.6       1.14        82.9  0        
## 3 Age            0.410     0.110        3.74 1.87e-  4
## 4 I(Age^2)      -0.00409   0.00182     -2.25 2.44e-  2
## 5 SexM           5.59      0.256       21.8  4.38e-103
\end{verbatim}

Funkce \texttt{glance()} vrací opět tabulku. Jejím obsahem ovšem nejsou údaje týkající se jednotlivých proměnných, ale modelu jako celku:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{glance}\NormalTok{(est\_model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1 x 12
##   r.squared adj.r.squared sigma statistic p.value    df  logLik    AIC    BIC
##       <dbl>         <dbl> <dbl>     <dbl>   <dbl> <dbl>   <dbl>  <dbl>  <dbl>
## 1     0.603         0.603  10.1     3431.       0     4 -33746. 67504. 67546.
## # ... with 3 more variables: deviance <dbl>, df.residual <int>, nobs <int>
\end{verbatim}

Tyto funkce jsou mimořádně užitečné při strojovém zpracovávání velkého množství odhadnutých modelů. Funkce z balíku \textbf{broom} přitom neslouží jenom pro převádění objektů \texttt{lm} do tabulky. Jejich záběr je mnohem obecnější a obsahují metody pro mnohem více tříd objektů.

Zvláštní pozornost se vyplatí věnovat funkci \texttt{predict()}. Ty v základní konfiguraci vrací prostě vyrovnané hodnoty:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{all.equal}\NormalTok{(}\FunctionTok{predict}\NormalTok{(est\_model),}\FunctionTok{fitted}\NormalTok{(est\_model))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] TRUE
\end{verbatim}

Při mnoha aplikacích nás spíše zajímá schopnost modelu predikovat out-of-sample. Tedy predikovat hodnoty vysvětlované proměnné na jiném vzorku dat, než který byl použit k odhadu parametrů. I pro tento účel se hodí funkce \texttt{predict()}.

Nejprve si tabulku \texttt{oly12} rozdělíme na dvě dílčí tabulky \texttt{oly12\_a} a \texttt{oly12\_b}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{idx }\OtherTok{\textless{}{-}} \FunctionTok{sample}\NormalTok{(}\FunctionTok{nrow}\NormalTok{(oly12), }\FunctionTok{round}\NormalTok{(}\FunctionTok{nrow}\NormalTok{(oly12)}\SpecialCharTok{/}\DecValTok{2}\NormalTok{))}

\NormalTok{oly12[idx,]  }\OtherTok{{-}\textgreater{}}\NormalTok{ oly12\_a}
\NormalTok{oly12[}\SpecialCharTok{{-}}\NormalTok{idx,]  }\OtherTok{{-}\textgreater{}}\NormalTok{ oly12\_b}
\end{Highlighting}
\end{Shaded}

Pro odhad parametrů použijeme tabulku \texttt{oly12\_a}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{oly12\_a }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{lm}\NormalTok{(model, }\AttributeTok{data=}\NormalTok{.) }\OtherTok{{-}\textgreater{}}\NormalTok{ est\_model\_a}
\end{Highlighting}
\end{Shaded}

Na základě odhadnutého modelu vypočítáme očekávané hodnoty \texttt{Weight} pro pozorování ze vzorku \texttt{oly12\_b}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{predict}\NormalTok{(est\_model\_a, }\AttributeTok{newdata =}\NormalTok{ oly12\_b) }\OtherTok{{-}\textgreater{}}\NormalTok{ prediction\_oly12\_b}
\end{Highlighting}
\end{Shaded}

Výsledkem je vektor predikovaných hodnot. Podívejme se, jak si model vedl při predikci out-of-sample:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{oly12\_b }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{bind\_cols}\NormalTok{(}\AttributeTok{.fitted =}\NormalTok{ prediction\_oly12\_b) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{mutate}\NormalTok{(}
        \AttributeTok{sample =} \StringTok{"B"}
\NormalTok{    ) }\OtherTok{{-}\textgreater{}}\NormalTok{ oly12\_b}

\NormalTok{est\_model\_a }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{augment}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{mutate}\NormalTok{(}
    \AttributeTok{sample =} \StringTok{"A"}
\NormalTok{  ) }\SpecialCharTok{\%\textgreater{}\%} 
  \FunctionTok{bind\_rows}\NormalTok{(oly12\_b) }\SpecialCharTok{\%\textgreater{}\%} 
     \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}
            \AttributeTok{x =}\NormalTok{ Weight,}
            \AttributeTok{y =}\NormalTok{ .fitted}
\NormalTok{        )}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{(}
        \AttributeTok{alpha =} \FloatTok{0.1}
\NormalTok{    ) }\SpecialCharTok{+}
  \FunctionTok{geom\_abline}\NormalTok{(}\AttributeTok{slope =} \DecValTok{1}\NormalTok{, }\AttributeTok{intercept =} \DecValTok{0}\NormalTok{, }\AttributeTok{color =} \StringTok{"red"}\NormalTok{) }\SpecialCharTok{+}
  \FunctionTok{facet\_wrap}\NormalTok{(}\StringTok{"sample"}\NormalTok{, }\AttributeTok{labeller =} \FunctionTok{as\_labeller}\NormalTok{(}
    \FunctionTok{c}\NormalTok{(}\StringTok{"A"}\OtherTok{=}\StringTok{"In{-}sample predictions"}\NormalTok{,}\StringTok{"B"}\OtherTok{=}\StringTok{"Out{-}of{-}sample predictions"}\NormalTok{)}
\NormalTok{    ))}
\end{Highlighting}
\end{Shaded}

\includegraphics{econometrics_files/figure-latex/unnamed-chunk-43-1.pdf}

Obrázky zhruba ukazují, že odhadnutý model si vede dobře i v out-of-sample predikcích. tedy predikcích vypočítaných na jiných datech, než jaké byly použity pro odhad modelu. Vzhledem k tomu, že vzorek byl rozdělen náhodně to asi není žádné velké překvapení.

\hypertarget{dalux161uxed-estimaux10dnuxed-funkce-a-kde-je-najuxedt}{%
\subsection{Další estimační funkce a kde je najít}\label{dalux161uxed-estimaux10dnuxed-funkce-a-kde-je-najuxedt}}

Následující tabulka představuje pár estimačních funkcí dostupných v R.

\begin{longtable}[]{@{}lll@{}}
\toprule
Model/estimátor & Funkce & Poznámka \\
\midrule
\endhead
Logit/probit & \texttt{glm()} & Modely diskrétní volby \\
Poisson & \texttt{glm()} & Count data \\
Poisson pseudo-ML (PPML) & \texttt{glm()} & Např. gravitační modely \\
Lineární panelová data & \texttt{plm::plm()} & pooled, FE, RE,\ldots{} \\
Arellano-Bond & \texttt{plm::pgmmm()} & Dynamické panely \\
Common Correlated Effects & \texttt{plm::pcce()} & Např. gravitační modely \\
Poisson, logit, ordered probit,\ldots{} (na panelu) & \texttt{pglm::pglm()} & \\
Tobit & \texttt{AER::tobit()} & \\
2SLS & \texttt{AER::ivreg()} & \\
Heckit (Tobit 2) & \texttt{sampleSelection::heckit()} & \\
\bottomrule
\end{longtable}

\ldots a mnoho, mnoho dalších.

\hypertarget{diagnostika}{%
\section{Diagnostika}\label{diagnostika}}

\hypertarget{vlivnuxe1-pozorovuxe1nuxed}{%
\subsection{Vlivná pozorování}\label{vlivnuxe1-pozorovuxe1nuxed}}

Populárním způsobem, jak najít pozorování, která významně ovlivňují výsledky modelu, je použití leave-one-out strategií. V nich se sleduje efekt vyloučení jednoho pozorování na odhady koeficientů, popřípadě na vyrovnaná pozorování. V R jsou implementovány v \texttt{influence.measures()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{influence.measures}\NormalTok{(est\_model) }\OtherTok{{-}\textgreater{}}\NormalTok{ infl\_obs}

\NormalTok{infl\_obs }\SpecialCharTok{\%\textgreater{}\%}\NormalTok{ class}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "infl"
\end{verbatim}

\texttt{influence.measures()} najednou volá celou řadu diagnostických testů -- mj. \texttt{dfbetas()} (vliv jednoho pozorování na odhadnuté koeficienty) a \texttt{dffits()} (vliv jednoho pozorování na vyrovnané hodnoty).

Výstupní objekt třídy \texttt{infl} obsahuje dva prvky (matice). \texttt{.\$infmat} obsahuje hodnoty jednotlivých statistik a \texttt{.\$is.inf} rozhodnutí (o podezření), zda se jedná o vlivné pozorování.

Viz obrázek:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{augment}\NormalTok{(est\_model) }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{bind\_cols}\NormalTok{(.,}\FunctionTok{as.data.frame}\NormalTok{(infl\_obs}\SpecialCharTok{$}\NormalTok{is.inf)) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{x=}\NormalTok{Weight,}
            \AttributeTok{y=}\NormalTok{.fitted)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}
            \AttributeTok{color =}\NormalTok{ dffit}
\NormalTok{            ),}
        \AttributeTok{alpha =} \FloatTok{0.2}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{xlab}\NormalTok{(}\StringTok{"Observed values"}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{ylab}\NormalTok{(}\StringTok{"Fitted values"}\NormalTok{) }\SpecialCharTok{+}
    \FunctionTok{scale\_color\_discrete}\NormalTok{(}\AttributeTok{name=}\StringTok{"Influential}\SpecialCharTok{\textbackslash{}n}\StringTok{observation}\SpecialCharTok{\textbackslash{}n}\StringTok{(DFFIT)"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{econometrics_files/figure-latex/unnamed-chunk-45-1.pdf}

Hodnoty, u kterých se predikce velmi odlišuje od pozorovaných hodnot jsou podle statistiky DFFIT jsou navrženy jako vlivné.

Tyto výsledky naznačují, že se v datech může dít něco zvláštního, nebo že nemáme k dispozici dostatečný počet pozorování z určité části prostoru -- v tomto případě například u sportovců s vyšší hmotností.

\hypertarget{normalita-reziduuxed}{%
\subsection{Normalita reziduí}\label{normalita-reziduuxed}}

Prvním způsobem, jak ověřit normalitu reziduí je pohledem na jejich rozdělení. Pomoci může například Q-Q plot, který porovnává kvantily normálního rozdělení a standardizovaných reziduí. V případě, že je rozdělení reziduí normální, by pozorování měla ležet na ose kvadrantu:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{augment}\NormalTok{(est\_model) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}\AttributeTok{sample =}\NormalTok{ .std.resid)}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_qq}\NormalTok{() }\SpecialCharTok{+}
    \FunctionTok{geom\_abline}\NormalTok{(}
        \AttributeTok{slope =} \DecValTok{1}\NormalTok{, }
        \AttributeTok{intercept =} \DecValTok{0}\NormalTok{,}
        \AttributeTok{color =} \StringTok{"red"}
\NormalTok{        )}
\end{Highlighting}
\end{Shaded}

\includegraphics{econometrics_files/figure-latex/unnamed-chunk-46-1.pdf}

Ani jeden okometrický test pro normalitu příliš nehovoří. Nicméně je potřeba nepodlehnout zdání. R poskytuje v balíku \texttt{normtest} celou baterii statistických testů.

Například můžeme zkusit otestovat normalitu pomocí Jarque-Bera testu:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(normtest)}

\FunctionTok{residuals}\NormalTok{(est\_model) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{jb.norm.test}\NormalTok{() }\OtherTok{{-}\textgreater{}}\NormalTok{ jb}

\FunctionTok{class}\NormalTok{(jb)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## [1] "htest"
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{print}\NormalTok{(jb)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
##  Jarque-Bera test for normality
## 
## data:  .
## JB = 82199, p-value < 2.2e-16
\end{verbatim}

Výstupem \texttt{jb.norm.test()} je objekt typu \texttt{htest}. Tato třída je oblíbená pro výsledky statistických testů. Pro tuto třídu existují metody v balíku \texttt{broom}, např.:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{tidy}\NormalTok{(jb)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 1 x 3
##   statistic p.value method                        
##       <dbl>   <dbl> <chr>                         
## 1    82199.       0 Jarque-Bera test for normality
\end{verbatim}

Nulovou hypotézou Jarque-Bera testu je normalita, kterou tento test zamítá.

\hypertarget{testy-linearity}{%
\subsection{Testy linearity}\label{testy-linearity}}

Z testů linearity je dostupný například Rainbow test, který srovnává kvalitu vyrovnání v modelech odhadnutých ``uprostřed'' pozorování a na celém vzorku.

V R je Rainbow test dostupný v balíku \texttt{lmtest} ve funkci \texttt{raintest}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{raintest}\NormalTok{(formula, }\AttributeTok{fraction =} \FloatTok{0.5}\NormalTok{, }\AttributeTok{order.by =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{center =} \ConstantTok{NULL}\NormalTok{,}
   \AttributeTok{data=}\FunctionTok{list}\NormalTok{())}
\end{Highlighting}
\end{Shaded}

Parametr \texttt{fraction} udává velikost samplu pro odhad modelu ``uprostřed''. V parametru \texttt{order.by} se udává proměnná, podél které se mají pozorování řadit.

Parametr \texttt{formula} může být naplněn i odhadnutým \texttt{lm} modelem. V tom případě není nutné zabývat se parametrem \texttt{data}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(lmtest)}
\FunctionTok{raintest}\NormalTok{(model, }\AttributeTok{order.by =} \SpecialCharTok{\textasciitilde{}}\NormalTok{ Height, }\AttributeTok{data =}\NormalTok{ oly12)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
##  Rainbow test
## 
## data:  model
## Rain = 1.1287, df1 = 4519, df2 = 4514, p-value = 2.397e-05
\end{verbatim}

Rain test v tomto případě zamítá nulovou hypotézu. To znamená, že fit na neomezeném vzorku je významně horší, než na podmnožině ``prostředních'' pozorování. Tento výsledek indikuje možný problém s linearitou.

\hypertarget{heteroskedasticita-a-odhad-robustnuxedch-chyb}{%
\subsection{Heteroskedasticita a odhad robustních chyb}\label{heteroskedasticita-a-odhad-robustnuxedch-chyb}}

Pokud je porušena homoskedasticita -- tzn. konstantní rozptyl náhodné složky -- potom není OLS estimátor BLUE (Best linear unbiased estimator), nicméně odhady parametrů jsou stále nevychýlené (unbiased). To bohužel neplatí pro odhady jejich rozptylu -- ty naopak vychýlené jsou a v důsledku jsou nedůvěryhodné i testy statistické významnosti parametrů.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{est\_model }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{augment}\NormalTok{() }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{arrange}\NormalTok{(Height) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{ggplot}\NormalTok{(}
        \FunctionTok{aes}\NormalTok{(}
            \AttributeTok{x =}\NormalTok{ Height,}
            \AttributeTok{y =}\NormalTok{ .resid}
\NormalTok{            )}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{geom\_point}\NormalTok{(}
        \AttributeTok{alpha =} \FloatTok{0.1}
\NormalTok{    ) }\SpecialCharTok{+}
    \FunctionTok{ylab}\NormalTok{(}\StringTok{"Residuals"}\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\includegraphics{econometrics_files/figure-latex/unnamed-chunk-51-1.pdf}

V reálném světě je podmínka homoskedasticity porušena velmi často. Jestli tomu tak je můžeme testovat pomocí mnoha testů. Jako příklad mohou sloužit příbuzné testy \texttt{bptest()} z balíku \texttt{lmtest} a \texttt{ncvTest} z balíku \texttt{car}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{lmtest}\SpecialCharTok{::}\FunctionTok{bptest}\NormalTok{(est\_model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
##  studentized Breusch-Pagan test
## 
## data:  est_model
## BP = 73.288, df = 4, p-value = 4.585e-15
\end{verbatim}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{car}\SpecialCharTok{::}\FunctionTok{ncvTest}\NormalTok{(est\_model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## Non-constant Variance Score Test 
## Variance formula: ~ fitted.values 
## Chisquare = 535.0632, Df = 1, p = < 2.22e-16
\end{verbatim}

Oba testy testují nulovou hypotézu o homoskedasticitě oba ji suverénně zamítají -- p-hodnoty obou testů jsou v podstatě nerozlišitelné od nuly.

Odhady směrodatných chyb lze korigovat použitím tzv. HC \emph{(heteroskedasticity consistent)} estimátorů kovarianční matice. Ty jsou implementovány například v balících \texttt{car} (\texttt{car::hccm}), ale zejména v balíku \texttt{sandwich}.

Balík \texttt{sandwich} obsahuje celou řadu nástrojů pro odhad kovarianční matice pro průřezová i panelová data. Bližší pozornost budeme věnovat dvěma. Základní funkci \texttt{vcovHC()} a také relativně nově implementované funkci pro výpočet klastrovaných robustních chyb \texttt{vcovCL()}.

Obě dvě funkce mají podobnou syntax:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{vcovHC}\NormalTok{(x,}
  \AttributeTok{type =} \FunctionTok{c}\NormalTok{(}\StringTok{"HC3"}\NormalTok{, }\StringTok{"const"}\NormalTok{, }\StringTok{"HC"}\NormalTok{, }\StringTok{"HC0"}\NormalTok{, }\StringTok{"HC1"}\NormalTok{, }\StringTok{"HC2"}\NormalTok{, }\StringTok{"HC4"}\NormalTok{, }\StringTok{"HC4m"}\NormalTok{, }\StringTok{"HC5"}\NormalTok{),}
  \AttributeTok{omega =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{sandwich =} \ConstantTok{TRUE}\NormalTok{, ...)}
\end{Highlighting}
\end{Shaded}

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{vcovCL}\NormalTok{(x, }\AttributeTok{cluster =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{type =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{sandwich =} \ConstantTok{TRUE}\NormalTok{, }\AttributeTok{fix =} \ConstantTok{FALSE}\NormalTok{, ...) }
\end{Highlighting}
\end{Shaded}

Vstupem funkce je odhadnutý model (\texttt{x}). V parametru \texttt{type} se potom specifikuje způsob korekce heteroskedasticity (viz \texttt{?vcovHC()}). V případě funkce \texttt{vcovCL()} je navíc nutné specifikovat proměnnou, nebo v případě více dimenzí proměnné, podle kterých se mají standardní chyby klastrovat. Klastrování se typicky používá v situaci, kdy určitá pozorování na sobě nejsou nezávislá. Klasický příklad je prospěch dětí z jedné třídy. Podstata dat sportovců naznačuje, že i v tomto případě je klastrování namístě. Jako specifické skupiny můžeme chápat sportovce věnující se jedné disciplině. Po \texttt{vcovCL()} tedy bude chtít spočítat kovarianční maticí klastrovanou podél proměnné \texttt{Sport}. Tu musíme dodat jako samostatný vektor. V objektu totiž není zahrnuta:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(sandwich)}
\FunctionTok{vcovCL}\NormalTok{(est\_model, }\AttributeTok{cluster =}\NormalTok{ oly12}\SpecialCharTok{$}\NormalTok{Sport)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
##               (Intercept)       Height          Age      I(Age^2)         SexM
## (Intercept) 144.744530958 -87.73269188  0.544857828 -7.405519e-03  9.080987791
## Height      -87.732691881  57.87470724 -0.914600493  1.437195e-02 -6.275686441
## Age           0.544857828  -0.91460049  0.079432487 -1.394717e-03  0.137949915
## I(Age^2)     -0.007405519   0.01437195 -0.001394717  2.566568e-05 -0.002251259
## SexM          9.080987791  -6.27568644  0.137949915 -2.251259e-03  0.979011051
\end{verbatim}

Výsledkem je odhad kovarianční matice. Zpravidla nás ovšem více zajímá odhad významnosti parametrů -- provedení statistických testů s použitím robustní kovarianční matice jako vstupu. Pro tento účel použijeme funkci \texttt{coeftest()} z balíku \texttt{lmtest}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{coeftest}\NormalTok{(x, }\AttributeTok{vcov. =} \ConstantTok{NULL}\NormalTok{, }\AttributeTok{df =} \ConstantTok{NULL}\NormalTok{, ...)}
\end{Highlighting}
\end{Shaded}

Prvním vstupem funkce \texttt{coeftest()} je odhadnutý model. (Funkce má implementovány metody pro modely třídy \texttt{lm} a \texttt{glm}.) Druhým parametrem je kovarianční matice nebo funkce, která se má použít pro její výpočet. Pokud je tento parametr ponechán prázdný, potom \texttt{coeftest()} použije nekorigovanou kovarianční matici:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(lmtest)}
\FunctionTok{coeftest}\NormalTok{(est\_model)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
## t test of coefficients:
## 
##                Estimate  Std. Error  t value  Pr(>|t|)    
## (Intercept) -1.0601e+02  2.3853e+00 -44.4438 < 2.2e-16 ***
## Height       9.4635e+01  1.1413e+00  82.9183 < 2.2e-16 ***
## Age          4.0966e-01  1.0960e-01   3.7378 0.0001868 ***
## I(Age^2)    -4.0944e-03  1.8193e-03  -2.2505 0.0244416 *  
## SexM         5.5916e+00  2.5603e-01  21.8397 < 2.2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
\end{verbatim}

Zadaní jména funkce jako parametru \texttt{vcov.} je vhodné tehdy, pokud nepotřebujete provádět žádné další nastavení parametrů výpočtu kovarianční matice:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{coeftest}\NormalTok{(est\_model, }\AttributeTok{vcov. =}\NormalTok{ vcovHC)}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
## t test of coefficients:
## 
##                Estimate  Std. Error  t value  Pr(>|t|)    
## (Intercept) -1.0601e+02  2.4526e+00 -43.2250 < 2.2e-16 ***
## Height       9.4635e+01  1.2120e+00  78.0841 < 2.2e-16 ***
## Age          4.0966e-01  9.2268e-02   4.4398 9.109e-06 ***
## I(Age^2)    -4.0944e-03  1.5164e-03  -2.7002  0.006944 ** 
## SexM         5.5916e+00  2.4404e-01  22.9123 < 2.2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
\end{verbatim}

V případě klastrovaných chyb však potřebuje takové nastavení provést -- minimálně potřebujeme zadat vektor podél kterého se má klastrovat. Do \texttt{vcov.} v tomto případě potřebujeme zadat celou kovarianční matici -- tedy výstup funkce \texttt{vcovCL}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{coeftest}\NormalTok{(est\_model, }\AttributeTok{vcov. =} \FunctionTok{vcovCL}\NormalTok{(est\_model, }\AttributeTok{cluster =}\NormalTok{ oly12}\SpecialCharTok{$}\NormalTok{Sport))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
## t test of coefficients:
## 
##                Estimate  Std. Error t value  Pr(>|t|)    
## (Intercept) -1.0601e+02  1.2031e+01 -8.8116 < 2.2e-16 ***
## Height       9.4635e+01  7.6075e+00 12.4396 < 2.2e-16 ***
## Age          4.0966e-01  2.8184e-01  1.4535    0.1461    
## I(Age^2)    -4.0944e-03  5.0661e-03 -0.8082    0.4190    
## SexM         5.5916e+00  9.8945e-01  5.6512 1.642e-08 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
\end{verbatim}

Klastrovat lze podél více proměnných. V tomto případě je potřeba do parametru \texttt{cluster} vložit list vektorů nebo \texttt{data.frame}. Nyní zkusíme cvičně klastrovat nejen podle sportovního odvětví, ale i podle pohlaví:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{coeftest}\NormalTok{(est\_model, }\AttributeTok{vcov. =} \FunctionTok{vcovCL}\NormalTok{(est\_model, }\AttributeTok{cluster =} \FunctionTok{list}\NormalTok{(oly12}\SpecialCharTok{$}\NormalTok{Sport, oly12}\SpecialCharTok{$}\NormalTok{Sex)))}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
## t test of coefficients:
## 
##                Estimate  Std. Error t value  Pr(>|t|)    
## (Intercept) -1.0601e+02  2.6150e+01 -4.0540 5.076e-05 ***
## Height       9.4635e+01  1.2569e+01  7.5295 5.584e-14 ***
## Age          4.0966e-01  3.3167e-01  1.2351    0.2168    
## I(Age^2)    -4.0944e-03  4.2600e-03 -0.9611    0.3365    
## SexM         5.5916e+00  1.1367e+00  4.9189 8.857e-07 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
\end{verbatim}

Výstupem funkce \texttt{coeftest()} je objekt speciální třídy \texttt{coeftest}. Pokud ho chceme převést na tabulku můžeme použít funkci \texttt{broom::tidy()}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{coeftest}\NormalTok{(est\_model, }\AttributeTok{vcov. =} \FunctionTok{vcovCL}\NormalTok{(est\_model, }\AttributeTok{cluster =} \FunctionTok{list}\NormalTok{(oly12}\SpecialCharTok{$}\NormalTok{Sport, oly12}\SpecialCharTok{$}\NormalTok{Sex))) }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{tidy}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 5 x 5
##   term          estimate std.error statistic  p.value
##   <chr>            <dbl>     <dbl>     <dbl>    <dbl>
## 1 (Intercept) -106.       26.1        -4.05  5.08e- 5
## 2 Height        94.6      12.6         7.53  5.58e-14
## 3 Age            0.410     0.332       1.24  2.17e- 1
## 4 I(Age^2)      -0.00409   0.00426    -0.961 3.37e- 1
## 5 SexM           5.59      1.14        4.92  8.86e- 7
\end{verbatim}

\hypertarget{dignostika-graficky}{%
\subsection{Dignostika graficky}\label{dignostika-graficky}}

V mnoha případech je užitečné se na diagnostiku podívat prostřednictvím vizualizací. Tuto možnost nabízí například funkce \texttt{plot()}, která má pro tento účel implementovanou metodu. Její fungování můžete vyzkoušet zadáním \texttt{plot(est\_model)}. Tento postup logicky pracuje se základní grafikou. Existují však i řešení, které podobně uživatelsky přítulně vykreslí diagnostické grafy s pomocí \texttt{ggplot2}. Jedním z nich je funkce \texttt{ggplot2::autoplot()}, která využívá služeb balíku \textbf{ggfortify}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(ggfortify)}
\FunctionTok{autoplot}\NormalTok{(est\_model)}
\end{Highlighting}
\end{Shaded}

\includegraphics{econometrics_files/figure-latex/unnamed-chunk-63-1.pdf}

\hypertarget{odhad-vuxedce-modelux16f}{%
\section{Odhad více modelů}\label{odhad-vuxedce-modelux16f}}

Často můžeme chtít odhadnout model v různých specifikacích, nebo na různých vzorcích dat.

\hypertarget{odhad-rux16fznuxfdch-specifikacuxed-na-stejnuxfdch-datech}{%
\subsection{Odhad různých specifikací na stejných datech}\label{odhad-rux16fznuxfdch-specifikacuxed-na-stejnuxfdch-datech}}

Častá úloha je odhad různých modelových specifikací na stejném vzorku pozorování. Pro tyto účely doporučuji následující postup:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Vytvořit si \texttt{list} se všemi rovnicemi (specifikacemi)
\item
  Odhadnout model pro všechny specifikace pomocí funkce \texttt{map()} z~balíku \textbf{purrr}
\end{enumerate}

Nejprve vytvoříme různé modelové specifikace s pomocí funkce \texttt{update()}:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{Models }\OtherTok{\textless{}{-}} \FunctionTok{list}\NormalTok{(}
    \CommentTok{\# Baseline model}
\NormalTok{    model,}
    \CommentTok{\# Přidána interakce Sex*Height}
\NormalTok{    model }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{update}\NormalTok{(.}\SpecialCharTok{\textasciitilde{}}\NormalTok{. }\SpecialCharTok{+}\NormalTok{ Sex}\SpecialCharTok{*}\NormalTok{Height),}
    \CommentTok{\# Přidán fixní efekt na zemi původu atleta}
\NormalTok{    model }\SpecialCharTok{\%\textgreater{}\%} \FunctionTok{update}\NormalTok{(.}\SpecialCharTok{\textasciitilde{}}\NormalTok{. }\SpecialCharTok{+} \FunctionTok{factor}\NormalTok{(Country))}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Nyní pomocí \texttt{purrr::map()} zavoláme \texttt{lm()} na všechny prvky listu \texttt{Models} -- tedy na všechny modelové specifikace:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{Spec\_models }\OtherTok{\textless{}{-}}\NormalTok{ purrr}\SpecialCharTok{::}\FunctionTok{map}\NormalTok{(Models, lm, }\AttributeTok{data =}\NormalTok{ VGAMdata}\SpecialCharTok{::}\NormalTok{oly12)}
\NormalTok{Spec\_models }\OtherTok{\textless{}{-}}\NormalTok{ purrr}\SpecialCharTok{::}\FunctionTok{map}\NormalTok{(Models, }\ControlFlowTok{function}\NormalTok{(x) }\FunctionTok{lm}\NormalTok{(x, }\AttributeTok{data =}\NormalTok{ VGAMdata}\SpecialCharTok{::}\NormalTok{oly12))}
\NormalTok{Spec\_models }\OtherTok{\textless{}{-}}\NormalTok{ purrr}\SpecialCharTok{::}\FunctionTok{map}\NormalTok{(Models, }\SpecialCharTok{\textasciitilde{}}\FunctionTok{lm}\NormalTok{(., }\AttributeTok{data =}\NormalTok{ VGAMdata}\SpecialCharTok{::}\NormalTok{oly12))}
\end{Highlighting}
\end{Shaded}

Všechny tři výše uvedené způsoby použití \texttt{map()} jsou v pořádku. Z~nějakého důvodu však balík \textbf{stargazer}, který budeme používat pro tvorbu výstupních tabulek, neumí pracovat se seznamem odhadnutých modelů, který byl vytvořen prvním způsobem.

Výsledné objekty jsou nyní uložené jako položky listu \texttt{Spec\_models}. K nim můžeme přistupovat pomocí subsetování:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{Spec\_models[[}\DecValTok{2}\NormalTok{]] }\SpecialCharTok{\%\textgreater{}\%}\NormalTok{ summary}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## 
## Call:
## lm(formula = ., data = VGAMdata::oly12)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -59.122  -5.646  -1.235   3.622 135.458 
## 
## Coefficients:
##               Estimate Std. Error t value Pr(>|t|)    
## (Intercept) -78.890968   3.402356 -23.187  < 2e-16 ***
## Height       78.901728   1.814233  43.490  < 2e-16 ***
## Age           0.392204   0.108875   3.602 0.000317 ***
## I(Age^2)     -0.003842   0.001807  -2.126 0.033527 *  
## SexM        -39.474467   4.065283  -9.710  < 2e-16 ***
## Height:SexM  25.695023   2.313338  11.107  < 2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 10.06 on 9032 degrees of freedom
##   (1346 observations deleted due to missingness)
## Multiple R-squared:  0.6084, Adjusted R-squared:  0.6082 
## F-statistic:  2807 on 5 and 9032 DF,  p-value: < 2.2e-16
\end{verbatim}

\hypertarget{odhad-modelu-na-duxedlux10duxedch-datech}{%
\subsection{Odhad modelu na dílčích datech}\label{odhad-modelu-na-duxedlux10duxedch-datech}}

Základní model můžeme odhadnout na různých vzorcích dat -- v tomto případě pro různé sporty (proměnná \texttt{Sport}). Pro podobnou operaci existuje více přístupů. Historicky byla pro takové operace určena funkce \texttt{dplyr::do()}. Ta však bude v budoucnosti v balíku \emph{dplyr} nahrazena a není ještě zcela jasné jak.

Dobrou variantou je postup analogický k odhadu více modelů na stejných datech. Nyní chceme odhadnout stejný model na různých datech. V předchozím případě jsme přes list rovnic iterovali pomocí funkce \texttt{map()}. Nyní bychom chtěli iterovat přes list tibblů. Ten vytvoříme pomocí funkce \texttt{split()} z base R.

Vstupy \texttt{split()} bude úplný tibble a vektor, podle kterého se má tento tibble rozdělit na menší tibblíky. Typicky je tento vektor přímo součástí vstupního tibble. To není problém -- můžeme využí placeholder \texttt{.}. Dejme tomu, že chceme odhadnout parametry pro každý sport zvlášť:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{Sport\_models }\OtherTok{\textless{}{-}}\NormalTok{ oly12 }\SpecialCharTok{\%\textgreater{}\%}
    \FunctionTok{split}\NormalTok{(.}\SpecialCharTok{$}\NormalTok{Sport) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{map}\NormalTok{(}
      \CommentTok{\# Zde si pomáháme anonymní funkcí, která nám}
      \CommentTok{\# pomůže doručit data do správného parametru}
      \CommentTok{\# funkce lm()}
        \ControlFlowTok{function}\NormalTok{(x) }\FunctionTok{lm}\NormalTok{(Models[[}\DecValTok{1}\NormalTok{]], }\AttributeTok{data =}\NormalTok{ x)}
\NormalTok{        )}
\end{Highlighting}
\end{Shaded}

Výsledná proměnná je list, který obsahuje odhadnuté modely:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{Sport\_models[}\DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{] }\SpecialCharTok{\%\textgreater{}\%}\NormalTok{ print}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## $Archery
## 
## Call:
## lm(formula = Models[[1]], data = x)
## 
## Coefficients:
## (Intercept)       Height          Age     I(Age^2)         SexM  
##  -45.146045    56.714558     0.459166     0.002153    10.191336  
## 
## 
## $Athletics
## 
## Call:
## lm(formula = Models[[1]], data = x)
## 
## Coefficients:
## (Intercept)       Height          Age     I(Age^2)         SexM  
##  -145.12558    123.04350     -0.40467      0.01024      2.15605  
## 
## 
## $Badminton
## 
## Call:
## lm(formula = Models[[1]], data = x)
## 
## Coefficients:
## (Intercept)       Height          Age     I(Age^2)         SexM  
##  -70.285717    75.702484     0.093450     0.001788     3.787492
\end{verbatim}

S modely uloženými v seznamu. Následující kód například opět za využívá \texttt{map()}. Pomocí \texttt{broom::glance()} vytvoří tabulku modelů seřazenou sestupně podle adjustovaného koeficientu determinace:

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{Sport\_models }\SpecialCharTok{\%\textgreater{}\%} 
  \CommentTok{\# Varinata map\_dfr() je ekvivalentní k map() \%\textgreater{}\% bind\_rows()}
    \FunctionTok{map\_dfr}\NormalTok{(glance) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{arrange}\NormalTok{(}\FunctionTok{desc}\NormalTok{(adj.r.squared)) }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{print}\NormalTok{()}
\end{Highlighting}
\end{Shaded}

\begin{verbatim}
## # A tibble: 26 x 12
##    r.squared adj.r.squared sigma statistic   p.value    df logLik   AIC   BIC
##        <dbl>         <dbl> <dbl>     <dbl>     <dbl> <dbl>  <dbl> <dbl> <dbl>
##  1     0.879         0.874  2.98      179. 4.32e- 44     4  -256.  524.  540.
##  2     0.878         0.870  3.81      110. 3.90e- 27     4  -179.  371.  384.
##  3     0.874         0.869  4.56      153. 9.52e- 39     4  -271.  553.  568.
##  4     0.850         0.848  6.01      423. 9.22e-122     4  -974. 1960. 1983.
##  5     0.837         0.835  4.29      485. 2.43e-147     4 -1099. 2209. 2233.
##  6     0.833         0.830  6.50      315. 6.52e- 97     4  -846. 1705. 1726.
##  7     0.819         0.815  4.49      171. 4.96e- 55     4  -453.  918.  936.
##  8     0.815         0.813  5.84      557. 5.13e-184     4 -1627. 3267. 3292.
##  9     0.806         0.805  5.04      887. 2.58e-302     4 -2605. 5223. 5251.
## 10     0.797         0.794  5.08      293. 3.55e-102     4  -923. 1858. 1880.
## # ... with 16 more rows, and 3 more variables: deviance <dbl>,
## #   df.residual <int>, nobs <int>
\end{verbatim}

(Pozn. takové řazení je užitečné jenom ve velmi omezeném počtu případů.)

\hypertarget{tvorba-pux11bknux11b-formuxe1tovanuxfdch-vuxfdsledkux16f-s-baluxedkem-stargazer}{%
\section{\texorpdfstring{Tvorba pěkně formátovaných výsledků s balíkem \texttt{stargazer}}{Tvorba pěkně formátovaných výsledků s balíkem stargazer}}\label{tvorba-pux11bknux11b-formuxe1tovanuxfdch-vuxfdsledkux16f-s-baluxedkem-stargazer}}

Pro porovnání výsledků odhadů je užitečné srovnat si je vedle sebe do tabulky, jakou znáte z empirických článků. Tento úkol umí splnit balík Marka Hlaváče \texttt{stargazer}.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{library}\NormalTok{(stargazer)}
\end{Highlighting}
\end{Shaded}

Stargazer dokáže vytvářet a do ASCII, HTML a LaTeXu exportovat:

\begin{itemize}
\tightlist
\item
  regresní tabulky
\item
  tabulky popisných statistik
\item
  exportovat vstupní \texttt{data.frame} bez další transformace (to je užitečné například pro export korelačních tabulek)
\end{itemize}

Balík \texttt{stargazer} obsahuje jedinou funkci \texttt{stargazer()}, která má velké množství parametrů -- srozumitelný tutoriál najdete například zde: \url{http://jakeruss.com/cheatsheets/stargazer.html}

Vstupem do funkce může být:

\begin{itemize}
\tightlist
\item
  jeden nebo více odhadnutých modelů různých tříd (viz seznam v helpu)
\item
  data.framy, vektory nebo matice pro tvorbu popisných statistik nebo přímý export
\end{itemize}

Vstupy mohou být vloženy jednotlivě nebo jako \texttt{list}, popřípadě \texttt{list} v \texttt{listu}.

\hypertarget{tabulka-s-popisnuxfdmi-statistikami}{%
\subsection{Tabulka s popisnými statistikami}\label{tabulka-s-popisnuxfdmi-statistikami}}

Tvorbu tabulky s popisnými statistikami je možné ilustrovat na minimalistickém příkladu. Vstupem je v tomto případě \texttt{data.frame}. Klíčovým parametrem je \texttt{summary\ =\ TRUE}, který říká \texttt{stargazeru}, že má vytvořit popisné statistiky. V případě \texttt{FALSE} by exportoval vstupní tabulku tak jak je.

Parametr \texttt{type} udává formát, do kterého \texttt{stargazer} exportuje. Možná nastavení jsou \texttt{html}, \texttt{text} a \texttt{latex} (default). Zde nevyužitým parametrem je \texttt{out} -- do něj se vkládá jméno výstupního souboru.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{stargazer}\NormalTok{(}
\NormalTok{    VGAMdata}\SpecialCharTok{::}\NormalTok{oly12,}
    \AttributeTok{summary =} \ConstantTok{TRUE}\NormalTok{,}
    \AttributeTok{type =} \StringTok{"latex"}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\% Table created by stargazer v.5.2.2 by Marek Hlavac, Harvard University. E-mail: hlavac at fas.harvard.edu
\% Date and time: Čt, čec 22, 2021 - 12:46:44

\begin{table}[!htbp] \centering 
  \caption{} 
  \label{} 
\begin{tabular}{@{\extracolsep{5pt}}lccccccc} 
\\[-1.8ex]\hline 
\hline \\[-1.8ex] 
Statistic & \multicolumn{1}{c}{N} & \multicolumn{1}{c}{Mean} & \multicolumn{1}{c}{St. Dev.} & \multicolumn{1}{c}{Min} & \multicolumn{1}{c}{Pctl(25)} & \multicolumn{1}{c}{Pctl(75)} & \multicolumn{1}{c}{Max} \\ 
\hline \\[-1.8ex] 
Age & 10,384 & 26.069 & 5.441 & 13 & 22 & 29 & 71 \\ 
Height & 9,823 & 1.769 & 0.113 & 1.320 & 1.690 & 1.850 & 2.210 \\ 
Weight & 9,104 & 72.853 & 16.067 & 36.000 & 61.000 & 81.000 & 218.000 \\ 
Gold & 10,384 & 0.017 & 0.136 & 0 & 0 & 0 & 2 \\ 
Silver & 10,384 & 0.017 & 0.133 & 0 & 0 & 0 & 2 \\ 
Bronze & 10,384 & 0.018 & 0.136 & 0 & 0 & 0 & 2 \\ 
Total & 10,384 & 0.052 & 0.250 & 0 & 0 & 0 & 5 \\ 
\hline \\[-1.8ex] 
\end{tabular} 
\end{table}

V základním nastavení \texttt{stargazer} vrací počet pozorování, průměr, směrodatnou odchylku, minimum a maximum. Výčet statistik, stejná jako formátování tabulky, lze měnit pomocí parametrů funkce \texttt{stargazer()}.

\textbf{Pozor, stargazer neumí zpracovat tibble!} Tabulka \texttt{oly12} je tibble:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{stargazer}\NormalTok{(}
\NormalTok{    oly12,}
    \AttributeTok{summary =} \ConstantTok{TRUE}\NormalTok{,}
    \AttributeTok{type =} \StringTok{"latex"}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

Výstup bude vypadat následovně:

\% Table created by stargazer v.5.2.2 by Marek Hlavac, Harvard University. E-mail: hlavac at fas.harvard.edu
\% Date and time: Čt, čec 22, 2021 - 12:46:44

\begin{table}[!htbp] \centering 
  \caption{} 
  \label{} 
\begin{tabular}{@{\extracolsep{5pt}}lccccccc} 
\\[-1.8ex]\hline 
\hline \\[-1.8ex] 
Statistic & \multicolumn{1}{c}{N} & \multicolumn{1}{c}{Mean} & \multicolumn{1}{c}{St. Dev.} & \multicolumn{1}{c}{Min} & \multicolumn{1}{c}{Pctl(25)} & \multicolumn{1}{c}{Pctl(75)} & \multicolumn{1}{c}{Max} \\ 
\hline \\[-1.8ex] 
\hline \\[-1.8ex] 
\end{tabular} 
\end{table}

Pro správnou funkci je potřeba tabulku odtibblovat -- například pomocí \texttt{as.data.frame(oly12)}.

\hypertarget{tabulka-s-regresnuxedmi-modely}{%
\subsection{Tabulka s regresními modely}\label{tabulka-s-regresnuxedmi-modely}}

Pokud jsou vstupem stagazeru odhadnuté modely nebo jejich list, potom \texttt{stargazer} automaticky vytvoří regresní tabulku. Pro ilustraci můžeme použít list \texttt{Spec\_models}.
Pro vytvoření regresní tabulky ze \texttt{Spec\_models} je vhodné použít další z mnoha parametrů funkce \texttt{stargazer()}. Jeden z modelů ve \texttt{Spec\_models} obsahuje velké množství fixních efektů. Jejich odhady nás v podstatě nezajímají, ale jejich výpis by tabulku zvětšil do obrovských rozměrů. Použijeme proto parametr \texttt{omit}, který umožňuje potlačit výpis parametrů, jejichž jména odpovídají zadanému regulárnímu výrazu.

V parametru \texttt{omit.labels} je možné nastavit jméno, které se má použít pro signalizaci přítomnosti nevytisknutých proměnných v regresi.

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{stargazer}\NormalTok{(}
\NormalTok{    Spec\_models,}
    \AttributeTok{type =} \FunctionTok{pandoc.output.format}\NormalTok{(),}
    \AttributeTok{omit =} \StringTok{"factor}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{(Country}\SpecialCharTok{\textbackslash{}\textbackslash{}}\StringTok{)"}\NormalTok{,}
    \AttributeTok{omit.labels =} \StringTok{"Country FE"}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\% Table created by stargazer v.5.2.2 by Marek Hlavac, Harvard University. E-mail: hlavac at fas.harvard.edu
\% Date and time: Čt, čec 22, 2021 - 12:46:44

\begin{table}[!htbp] \centering 
  \caption{} 
  \label{} 
\begin{tabular}{@{\extracolsep{5pt}}lccc} 
\\[-1.8ex]\hline 
\hline \\[-1.8ex] 
 & \multicolumn{3}{c}{\textit{Dependent variable:}} \\ 
\cline{2-4} 
\\[-1.8ex] & \multicolumn{3}{c}{Weight} \\ 
\\[-1.8ex] & (1) & (2) & (3)\\ 
\hline \\[-1.8ex] 
 Height & 94.635$^{***}$ & 78.902$^{***}$ & 94.887$^{***}$ \\ 
  & (1.141) & (1.814) & (1.234) \\ 
  & & & \\ 
 Age & 0.410$^{***}$ & 0.392$^{***}$ & 0.491$^{***}$ \\ 
  & (0.110) & (0.109) & (0.110) \\ 
  & & & \\ 
 I(Age$\hat{\mkern6mu}$2) & $-$0.004$^{**}$ & $-$0.004$^{**}$ & $-$0.005$^{***}$ \\ 
  & (0.002) & (0.002) & (0.002) \\ 
  & & & \\ 
 SexM & 5.592$^{***}$ & $-$39.474$^{***}$ & 5.502$^{***}$ \\ 
  & (0.256) & (4.065) & (0.266) \\ 
  & & & \\ 
 Height:SexM &  & 25.695$^{***}$ &  \\ 
  &  & (2.313) &  \\ 
  & & & \\ 
 Constant & $-$106.013$^{***}$ & $-$78.891$^{***}$ & $-$112.691$^{***}$ \\ 
  & (2.385) & (3.402) & (6.240) \\ 
  & & & \\ 
\hline \\[-1.8ex] 
Country FE & No & No & No \\ 
\hline \\[-1.8ex] 
Observations & 9,038 & 9,038 & 9,038 \\ 
R$^{2}$ & 0.603 & 0.608 & 0.628 \\ 
Adjusted R$^{2}$ & 0.603 & 0.608 & 0.620 \\ 
Residual Std. Error & 10.126 (df = 9033) & 10.058 (df = 9032) & 9.909 (df = 8837) \\ 
F Statistic & 3,430.928$^{***}$ (df = 4; 9033) & 2,806.601$^{***}$ (df = 5; 9032) & 74.631$^{***}$ (df = 200; 8837) \\ 
\hline 
\hline \\[-1.8ex] 
\textit{Note:}  & \multicolumn{3}{r}{$^{*}$p$<$0.1; $^{**}$p$<$0.05; $^{***}$p$<$0.01} \\ 
\end{tabular} 
\end{table}

Za povšimnutí stojí, že \texttt{stargazer} defaultně používá jinou hvězdičkovou konvenci, než je tomu ve zbytku R. Ve v tabulce vytvořené stargazerem vidíte stejnou konvenci, na kterou jste zvyklí z Gretlu. R defaultně hvězdičkami více šetří -- viz \texttt{summary} výše.

\begin{quote}
Stargazer poskytuje extrémně užitečnou funkcionalitu, nicméně celkově se jedná o dost nemoderní balík s velmi složitým kódem, který je náchylný k chybám a divnému chování.
\end{quote}

Výše ukázané tabulky neobsahují robustní chyby. Protože z testů víme, že rezidua jsou heteroskedastická, musíme je do tabulek dostat.

V defaultním nastavení \texttt{stargazer} získává odhad standardních chyb vnitřním voláním \texttt{summary}. Uživatel však může vložit vlastní odhady robustních chyb do argumentu \texttt{se}. Ten očekává \texttt{list} numerických vektorů. (V nápovědě k parametru \texttt{se} je v aktuální verzi chyba.)

Postup je následující:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  Nejprve vytvoříme funkci \texttt{get.se()}, která odhadne robustní chyby a vrátí je jako vektor.
\item
  Pomocí \texttt{purrr::map()} aplikujeme funkci \texttt{get.se()} na všechny modely v listu \texttt{Spec\_models}.
\item
  Výsledný seznam vektorů vložíme do parametru \texttt{se} funkce \texttt{stargazer()}.
\end{enumerate}

Zároveň totéž provedeme pro p-hodnoty.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{get.se }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x) }\FunctionTok{coeftest}\NormalTok{(x, }\AttributeTok{vcov. =}\NormalTok{ vcovHC) }\SpecialCharTok{\%\textgreater{}\%} 
\NormalTok{    tidy }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{pull}\NormalTok{(std.error)}

\NormalTok{get.pval }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(x) }\FunctionTok{coeftest}\NormalTok{(x, }\AttributeTok{vcov. =}\NormalTok{ vcovHC) }\SpecialCharTok{\%\textgreater{}\%} 
\NormalTok{    tidy }\SpecialCharTok{\%\textgreater{}\%} 
    \FunctionTok{pull}\NormalTok{(p.value)}

\NormalTok{se.list }\OtherTok{\textless{}{-}}\NormalTok{ purrr}\SpecialCharTok{::}\FunctionTok{map}\NormalTok{(Spec\_models, get.se)}
\NormalTok{pval.list }\OtherTok{\textless{}{-}}\NormalTok{ purrr}\SpecialCharTok{::}\FunctionTok{map}\NormalTok{(Spec\_models, get.pval)}

\FunctionTok{stargazer}\NormalTok{(}
\NormalTok{    Spec\_models,}
    \AttributeTok{type =} \FunctionTok{pandoc.output.format}\NormalTok{(),}
    \AttributeTok{omit =} \StringTok{"Country"}\NormalTok{,}
    \AttributeTok{omit.labels =} \StringTok{"Country FE"}\NormalTok{,}
    \AttributeTok{se =}\NormalTok{ se.list,}
    \AttributeTok{p =}\NormalTok{ pval.list}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\% Table created by stargazer v.5.2.2 by Marek Hlavac, Harvard University. E-mail: hlavac at fas.harvard.edu
\% Date and time: Čt, čec 22, 2021 - 12:46:46

\begin{table}[!htbp] \centering 
  \caption{} 
  \label{} 
\begin{tabular}{@{\extracolsep{5pt}}lccc} 
\\[-1.8ex]\hline 
\hline \\[-1.8ex] 
 & \multicolumn{3}{c}{\textit{Dependent variable:}} \\ 
\cline{2-4} 
\\[-1.8ex] & \multicolumn{3}{c}{Weight} \\ 
\\[-1.8ex] & (1) & (2) & (3)\\ 
\hline \\[-1.8ex] 
 Height & 94.635$^{***}$ & 78.902$^{***}$ & 94.887 \\ 
  & (1.212) & (1.682) &  \\ 
  & & & \\ 
 Age & 0.410$^{***}$ & 0.392$^{***}$ & 0.491 \\ 
  & (0.092) & (0.091) &  \\ 
  & & & \\ 
 I(Age$\hat{\mkern6mu}$2) & $-$0.004$^{***}$ & $-$0.004$^{**}$ & $-$0.005 \\ 
  & (0.002) & (0.002) &  \\ 
  & & & \\ 
 SexM & 5.592$^{***}$ & $-$39.474$^{***}$ & 5.502 \\ 
  & (0.244) & (4.125) &  \\ 
  & & & \\ 
 Height:SexM &  & 25.695$^{***}$ &  \\ 
  &  & (2.352) &  \\ 
  & & & \\ 
 Constant & $-$106.013$^{***}$ & $-$78.891$^{***}$ & $-$112.691 \\ 
  & (2.453) & (3.149) &  \\ 
  & & & \\ 
\hline \\[-1.8ex] 
Country FE & No & No & No \\ 
\hline \\[-1.8ex] 
Observations & 9,038 & 9,038 & 9,038 \\ 
R$^{2}$ & 0.603 & 0.608 & 0.628 \\ 
Adjusted R$^{2}$ & 0.603 & 0.608 & 0.620 \\ 
Residual Std. Error & 10.126 (df = 9033) & 10.058 (df = 9032) & 9.909 (df = 8837) \\ 
F Statistic & 3,430.928$^{***}$ (df = 4; 9033) & 2,806.601$^{***}$ (df = 5; 9032) & 74.631$^{***}$ (df = 200; 8837) \\ 
\hline 
\hline \\[-1.8ex] 
\textit{Note:}  & \multicolumn{3}{r}{$^{*}$p$<$0.1; $^{**}$p$<$0.05; $^{***}$p$<$0.01} \\ 
\end{tabular} 
\end{table}

Pokud bychom chtěli vytvořit regresní tabulku z modelů odhadnutých pro jednotlivé sporty, můžeme využít toho, že \texttt{data.frame} je ve své podstatě \texttt{list}:

\begin{Shaded}
\begin{Highlighting}[]
\FunctionTok{stargazer}\NormalTok{(}
\NormalTok{    Sport\_models}\SpecialCharTok{$}\NormalTok{est\_model,}
    \AttributeTok{type =} \StringTok{"html"}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\hypertarget{alternativy-k-baluxedku-stargazer}{%
\section{\texorpdfstring{Alternativy k balíku \emph{stargazer}}{Alternativy k balíku stargazer}}\label{alternativy-k-baluxedku-stargazer}}

\hypertarget{part-reproducible-research}{%
\part{Reproducible research}\label{part-reproducible-research}}

  \bibliography{book.bib,packages.bib}

\end{document}
