galaaz 0.4.9 → 0.4.10

data/blogs/manual/manual.tex

@@ -0,0 +1,2816 @@
+\documentclass[11pt,]{article}
+\usepackage{lmodern}
+\usepackage{amssymb,amsmath}
+\usepackage{ifxetex,ifluatex}
+\usepackage{fixltx2e} % provides \textsubscript
+\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex
+  \usepackage[T1]{fontenc}
+  \usepackage[utf8]{inputenc}
+\else % if luatex or xelatex
+  \ifxetex
+    \usepackage{mathspec}
+  \else
+    \usepackage{fontspec}
+  \fi
+  \defaultfontfeatures{Ligatures=TeX,Scale=MatchLowercase}
+\fi
+% use upquote if available, for straight quotes in verbatim environments
+\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
+% use microtype if available
+\IfFileExists{microtype.sty}{%
+\usepackage{microtype}
+\UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
+}{}
+\usepackage[margin=1in]{geometry}
+\usepackage{hyperref}
+\hypersetup{unicode=true,
+            pdftitle={Galaaz Manual},
+            pdfauthor={Rodrigo Botafogo},
+            pdfborder={0 0 0},
+            breaklinks=true}
+\urlstyle{same}  % don't use monospace 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}
+\usepackage{graphicx,grffile}
+\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}
+\IfFileExists{parskip.sty}{%
+\usepackage{parskip}
+}{% else
+\setlength{\parindent}{0pt}
+\setlength{\parskip}{6pt plus 2pt minus 1pt}
+}
+\setlength{\emergencystretch}{3em}  % prevent overfull lines
+\providecommand{\tightlist}{%
+  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
+\setcounter{secnumdepth}{5}
+% Redefines (sub)paragraphs to behave more like sections
+\ifx\paragraph\undefined\else
+\let\oldparagraph\paragraph
+\renewcommand{\paragraph}[1]{\oldparagraph{#1}\mbox{}}
+\fi
+\ifx\subparagraph\undefined\else
+\let\oldsubparagraph\subparagraph
+\renewcommand{\subparagraph}[1]{\oldsubparagraph{#1}\mbox{}}
+\fi
+
+%%% Use protect on footnotes to avoid problems with footnotes in titles
+\let\rmarkdownfootnote\footnote%
+\def\footnote{\protect\rmarkdownfootnote}
+
+%%% Change title format to be more compact
+\usepackage{titling}
+
+% Create subtitle command for use in maketitle
+\newcommand{\subtitle}[1]{
+  \posttitle{
+    \begin{center}\large#1\end{center}
+    }
+}
+
+\setlength{\droptitle}{-2em}
+
+  \title{Galaaz Manual}
+    \pretitle{\vspace{\droptitle}\centering\huge}
+  \posttitle{\par}
+  \subtitle{How to tightly couple Ruby and R in GraalVM}
+  \author{Rodrigo Botafogo}
+    \preauthor{\centering\large\emph}
+  \postauthor{\par}
+      \predate{\centering\large\emph}
+  \postdate{\par}
+    \date{2019}
+
+% usar portugues do Brasil
+% \usepackage[brazilian]{babel}
+\usepackage[utf8]{inputenc}
+
+\usepackage{geometry}
+\geometry{a4paper, top=1in}
+
+% needed for kableExtra
+\usepackage{longtable}
+\usepackage{multirow}
+\usepackage[table]{xcolor}
+\usepackage{wrapfig}
+\usepackage{float}
+\usepackage{colortbl}
+\usepackage{pdflscape}
+\usepackage{tabu}
+\usepackage{threeparttable}
+\usepackage[normalem]{ulem}
+
+\usepackage{bbm}
+\usepackage{booktabs}
+\usepackage{expex}
+
+\usepackage{graphicx}
+
+\usepackage{fancyhdr}
+% set the header and foot style
+% style 'fancy' adds the section name on the header
+% and the page number on the footer
+\pagestyle{fancy}
+
+% style 'fancyhf' leaves header and footer empty
+%\fancyhf{}
+
+% sets the left head element to \rightmark, which contains the
+% current section (\leftmark is the current chapter)
+%\fancyhead[L]{\rightmark} .
+
+% sets the right head element to the page number.
+% \fancyhead[R]{\thepage}
+
+% lets the head rule disappear.
+% \renewcommand{\headrulewidth}{0pt}
+% Possible selectors for the optional argument of \fancyhead/\fancyfoot
+% are L (left), C (center) or R (right) for the position of the element
+% and E (even) or O (odd) to distinguish even and odd pages. If you omit
+% E/O the element is set for all pages.
+
+% \usepackage{lipsum}
+
+% make available command lastpage
+\usepackage{lastpage}
+
+% default fontsize 11pt better to add
+% fontsize on the yaml header
+% \usepackage[fontsize=11pt]{scrextend}
+
+% comandos para formatar uma tabela
+\usepackage{array}
+\newcolumntype{L}[1]{>{\raggedright\let\newline\\\arraybackslash\hspace{0pt}}m{#1}}
+\newcolumntype{C}[1]{>{\centering\let\newline\\\arraybackslash\hspace{0pt}}m{#1}}
+\newcolumntype{R}[1]{>{\raggedleft\let\newline\\\arraybackslash\hspace{0pt}}m{#1}}
+
+% necessário if we need to import other latex documents
+\usepackage{import}
+
+% Command to import an R variable to latex
+\newcommand{\RtoLatex}[2]{\newcommand{#1}{#2}}
+
+% 
+%\newcommand{\atraso}[1]{\color{red} \textbf {Tempo desde a Assinatura do Contrato: #1 dias}}
+\usepackage{booktabs}
+\usepackage{longtable}
+\usepackage{array}
+\usepackage{multirow}
+\usepackage{wrapfig}
+\usepackage{float}
+\usepackage{colortbl}
+\usepackage{pdflscape}
+\usepackage{tabu}
+\usepackage{threeparttable}
+\usepackage{threeparttablex}
+\usepackage[normalem]{ulem}
+\usepackage{makecell}
+\usepackage{xcolor}
+
+\begin{document}
+\maketitle
+
+{
+\setcounter{tocdepth}{2}
+\tableofcontents
+}
+\hypertarget{introduction}{%
+\section{Introduction}\label{introduction}}
+
+Galaaz is a system for tightly coupling Ruby and R. Ruby is a powerful
+language, with a large community, a very large set of libraries and
+great for web development. However, it lacks libraries for data science,
+statistics, scientific plotting and machine learning. On the other hand,
+R is considered one of the most powerful languages for solving all of
+the above problems. Maybe the strongest competitor to R is Python with
+libraries such as NumPy, Panda, SciPy, SciKit-Learn and a couple more.
+
+\hypertarget{system-compatibility}{%
+\section{System Compatibility}\label{system-compatibility}}
+
+\begin{itemize}
+\tightlist
+\item
+  Oracle Linux 7
+\item
+  Ubuntu 18.04 LTS
+\item
+  Ubuntu 16.04 LTS
+\item
+  Fedora 28
+\item
+  macOS 10.14 (Mojave)
+\item
+  macOS 10.13 (High Sierra)
+\end{itemize}
+
+\hypertarget{dependencies}{%
+\section{Dependencies}\label{dependencies}}
+
+\begin{itemize}
+\tightlist
+\item
+  TruffleRuby
+\item
+  FastR
+\end{itemize}
+
+\hypertarget{installation}{%
+\section{Installation}\label{installation}}
+
+\begin{itemize}
+\tightlist
+\item
+  Install GrallVM (\url{http://www.graalvm.org/})
+\item
+  Install Ruby (gu install Ruby)
+\item
+  Install FastR (gu install R)
+\item
+  Install rake if you want to run the specs and examples (gem install
+  rake)
+\end{itemize}
+
+\hypertarget{usage}{%
+\section{Usage}\label{usage}}
+
+\begin{itemize}
+\item
+  Interactive shell: use `gstudio' on the command line
+
+  \begin{quote}
+  gstudio
+  \end{quote}
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{  vec = R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{)}
+\NormalTok{  puts vec}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3 4
+\end{verbatim}
+
+\begin{itemize}
+\item
+  Run all specs
+
+  \begin{quote}
+  galaaz specs:all
+  \end{quote}
+\item
+  Run graphics slideshow (80+ graphics)
+
+  \begin{quote}
+  galaaz sthda:all
+  \end{quote}
+\item
+  Run labs from Introduction to Statistical Learning with R
+
+  \begin{quote}
+  galaaz islr:all
+  \end{quote}
+\item
+  See all available examples
+
+  \begin{quote}
+  galaaz -T
+  \end{quote}
+
+  Shows a list with all available executalbe tasks. To execute a task,
+  substitute the `rake' word in the list with `galaaz'. For instance,
+  the following line shows up after `galaaz -T'
+
+  rake master\_list:scatter\_plot \# scatter\_plot from:\ldots{}.
+
+  execute
+
+  \begin{quote}
+  galaaz master\_list:scatter\_plot
+  \end{quote}
+\end{itemize}
+
+\hypertarget{gknitting-a-document}{%
+\section{gKnitting a Document}\label{gknitting-a-document}}
+
+This manual has been formatted usign gKnit. gKnit uses Knitr and R
+markdown to knit a document in Ruby or R and output it in any of the
+available formats for R markdown. gKnit runs atop of GraalVM, and
+Galaaz. In gKnit, Ruby variables are persisted between chunks, making it
+an ideal solution for literate programming. Also, since it is based on
+Galaaz, Ruby chunks can have access to R variables and Polyglot
+Programming with Ruby and R is quite natural.
+
+\href{https://towardsdatascience.com/how-to-do-reproducible-research-in-ruby-with-gknit-c26d2684d64e}{gknit
+is described in more details here}
+
+\hypertarget{vector}{%
+\section{Vector}\label{vector}}
+
+Vectors can be thought of as contiguous cells containing data. Cells are
+accessed through indexing operations such as x{[}5{]}. Galaaz has six
+basic (`atomic') vector types: logical, integer, real, complex, string
+(or character) and raw. The modes and storage modes for the different
+vector types are listed in the following table.
+
+\begin{longtable}[]{@{}lcr@{}}
+\toprule
+typeof & mode & storage.mode\tabularnewline
+\midrule
+\endhead
+logical & logical & logical\tabularnewline
+integer & numeric & integer\tabularnewline
+double & numeric & double\tabularnewline
+complex & complex & comples\tabularnewline
+character & character & character\tabularnewline
+raw & raw & raw\tabularnewline
+\bottomrule
+\end{longtable}
+
+Single numbers, such as 4.2, and strings, such as ``four point two'' are
+still vectors, of length 1; there are no more basic types. Vectors with
+length zero are possible (and useful). String vectors have mode and
+storage mode ``character''. A single element of a character vector is
+often referred to as a character string.
+
+To create a vector the `c' (concatenate) method from the `R' module
+should be used:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec = R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
+\NormalTok{puts vec}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3
+\end{verbatim}
+
+Lets take a look at the type, mode and storage.mode of our vector vec.
+In order to print this out, we are creating a data frame `df' and
+printing it out. A data frame, for those not familiar with it, is
+basically a table. Here we create the data frame and add the column name
+by passing named parameters for each column, such as `typeof:', `mode:'
+and 'storage\_\_mode?`. You should also note here that the double
+underscore is converted to a'.'. So, when printed `storage\_\_mode' will
+actually print as `storage.mode'.
+
+Data frames will later be more carefully described. In R, the method
+used to create a data frame is `data.frame', in Galaaz we use
+`data\_\_frame'.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df = R.data__frame(}\StringTok{typeof: }\NormalTok{vec.typeof, }\StringTok{mode: }\NormalTok{vec.mode, }\StringTok{storage__mode: }\NormalTok{vec.storage__mode)}
+\NormalTok{puts df}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##    typeof    mode storage.mode
+## 1 integer numeric      integer
+\end{verbatim}
+
+If you want to create a vector with floating point numbers, then we need
+at least one of the vector's element to be a float, such as 1.0. R users
+should be careful, since in R a number like `1' is converted to float
+and to have an integer the R developer will use `1L'. Galaaz follows
+normal Ruby rules and the number 1 is an integer and 1.0 is a float.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec = R.c(}\FloatTok{1.0}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
+\NormalTok{puts vec}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df = R.data__frame(}\StringTok{typeof: }\NormalTok{vec.typeof, }\StringTok{mode: }\NormalTok{vec.mode, }\StringTok{storage__mode: }\NormalTok{vec.storage__mode)}
+\NormalTok{outputs df.kable.kable_styling}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{table}[H]
+\centering
+\begin{tabular}{l|l|l}
+\hline
+typeof & mode & storage.mode\\
+\hline
+double & numeric & double\\
+\hline
+\end{tabular}
+\end{table}
+
+In this next example we try to create a vector with a variable `hello'
+that has not yet being defined. This will raise an exception that is
+printed out. We get two return blocks, the first with a message
+explaining what went wrong and the second with the full backtrace of the
+error.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec = R.c(}\DecValTok{1}\NormalTok{, hello, }\DecValTok{5}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Message:
+##  undefined local variable or method `hello' for #<RC:0x2e0 @out_list=nil>:RC
+\end{verbatim}
+
+\begin{verbatim}
+## Message:
+##  /home/rbotafogo/desenv/galaaz/lib/util/exec_ruby.rb:103:in `get_binding'
+## /home/rbotafogo/desenv/galaaz/lib/util/exec_ruby.rb:102:in `eval'
+## /home/rbotafogo/desenv/galaaz/lib/util/exec_ruby.rb:102:in `exec_ruby'
+## /home/rbotafogo/desenv/galaaz/lib/gknit/knitr_engine.rb:650:in `block in initialize'
+## /home/rbotafogo/desenv/galaaz/lib/R_interface/ruby_callback.rb:77:in `call'
+## /home/rbotafogo/desenv/galaaz/lib/R_interface/ruby_callback.rb:77:in `callback'
+## (eval):3:in `function(...) {\n          rb_method(...)'
+## unknown.r:1:in `in_dir'
+## unknown.r:1:in `block_exec:BLOCK0'
+## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/block.R:102:in `block_exec'
+## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/block.R:92:in `call_block'
+## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/block.R:6:in `process_group.block'
+## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/block.R:3:in `<no source>'
+## unknown.r:1:in `withCallingHandlers'
+## unknown.r:1:in `process_file'
+## unknown.r:1:in `<no source>:BLOCK1'
+## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/output.R:129:in `<no source>'
+## unknown.r:1:in `<no source>:BLOCK1'
+## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/rmarkdown/R/render.R:162:in `<no source>'
+## <REPL>:5:in `<repl wrapper>'
+## <REPL>:1
+\end{verbatim}
+
+Here is a vector with logical values
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec = R.c(}\DecValTok{true}\NormalTok{, }\DecValTok{true}\NormalTok{, }\DecValTok{false}\NormalTok{, }\DecValTok{false}\NormalTok{, }\DecValTok{true}\NormalTok{)}
+\NormalTok{puts vec}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1]  TRUE  TRUE FALSE FALSE  TRUE
+\end{verbatim}
+
+\hypertarget{combining-vectors}{%
+\subsection{Combining Vectors}\label{combining-vectors}}
+
+The `c' functions used to create vectors can also be used to combine two
+vectors:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec1 = R.c(}\FloatTok{10.0}\NormalTok{, }\FloatTok{20.0}\NormalTok{, }\FloatTok{30.0}\NormalTok{)}
+\NormalTok{vec2 = R.c(}\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{)}
+\NormalTok{vec = R.c(vec1, vec2)}
+\NormalTok{puts vec}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 10 20 30  4  5  6
+\end{verbatim}
+
+In galaaz, methods can be chainned (somewhat like the pipe operator in R
+\%\textgreater{}\%, but more generic). In this next example, method `c'
+is chainned after `vec1'. This also looks like `c' is a method of the
+vector, but in reallity, this is actually closer to the pipe operator.
+When Galaaz identifies that `c' is not a method of `vec' it actually
+tries to call `R.c' with `vec1' as the first argument concatenated with
+all the other available arguments. The code bellow is automatically
+converted to the code above.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec = vec1.c(vec2)}
+\NormalTok{puts vec}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 10 20 30  4  5  6
+\end{verbatim}
+
+\hypertarget{vector-arithmetic}{%
+\subsection{Vector Arithmetic}\label{vector-arithmetic}}
+
+Arithmetic operations on vectors are performed element by element:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec1 + vec2}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 14 25 36
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec1 * }\DecValTok{5}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1]  50 100 150
+\end{verbatim}
+
+When vectors have different length, a recycling rule is applied to the
+shorter vector:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec3 = R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{, }\FloatTok{7.0}\NormalTok{, }\FloatTok{8.0}\NormalTok{, }\FloatTok{9.0}\NormalTok{)}
+\NormalTok{puts vec4 = vec1 + vec3}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 11 22 33 14 25 36 17 28 39
+\end{verbatim}
+
+\hypertarget{vector-indexing}{%
+\subsection{Vector Indexing}\label{vector-indexing}}
+
+Vectors can be indexed by using the `{[}{]}' operator:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec4[}\DecValTok{3}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 33
+\end{verbatim}
+
+We can also index a vector with another vector. For example, in the code
+bellow, we take elements 1, 3, 5, and 7 from vec3:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec4[R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{7}\NormalTok{)]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 11 33 25 17
+\end{verbatim}
+
+Repeating an index and having indices out of order is valid code:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec4[R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{1}\NormalTok{)]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 11 33 33 11
+\end{verbatim}
+
+It is also possible to index a vector with a negative number or negative
+vector. In these cases the indexed values are not returned:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec4[-}\DecValTok{3}\NormalTok{]}
+\NormalTok{puts vec4[-R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{7}\NormalTok{)]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 11 22 14 25 36 17 28 39
+## [1] 22 14 36 28 39
+\end{verbatim}
+
+If an index is out of range, a missing value (NA) will be reported.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec4[}\DecValTok{30}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] NA
+\end{verbatim}
+
+It is also possible to index a vector by range:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec4[(}\DecValTok{2}\NormalTok{..}\DecValTok{5}\NormalTok{)]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 22 33 14 25
+\end{verbatim}
+
+Elements in a vector can be named using the `names' attribute of a
+vector:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{full_name = R.c(}\StringTok{"Rodrigo"}\NormalTok{, }\StringTok{"A"}\NormalTok{, }\StringTok{"Botafogo"}\NormalTok{)}
+\NormalTok{full_name.names = R.c(}\StringTok{"First"}\NormalTok{, }\StringTok{"Middle"}\NormalTok{, }\StringTok{"Last"}\NormalTok{)}
+\NormalTok{puts full_name}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      First     Middle       Last 
+##  "Rodrigo"        "A" "Botafogo"
+\end{verbatim}
+
+Or it can also be named by using the `c' function with named
+paramenters:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{full_name = R.c(}\DataTypeTok{First}\NormalTok{: }\StringTok{"Rodrigo"}\NormalTok{, }\DataTypeTok{Middle}\NormalTok{: }\StringTok{"A"}\NormalTok{, }\DataTypeTok{Last}\NormalTok{: }\StringTok{"Botafogo"}\NormalTok{)}
+\NormalTok{puts full_name}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      First     Middle       Last 
+##  "Rodrigo"        "A" "Botafogo"
+\end{verbatim}
+
+\hypertarget{extracting-native-ruby-types-from-a-vector}{%
+\subsection{Extracting Native Ruby Types from a
+Vector}\label{extracting-native-ruby-types-from-a-vector}}
+
+Vectors created with `R.c' are of class R::Vector. You might have
+noticed that when indexing a vector, a new vector is returned, even if
+this vector has one single element. In order to use R::Vector with other
+ruby classes it might be necessary to extract the actual Ruby native
+type from the vector. In order to do this extraction the
+`\textgreater{}\textgreater{}' operator is used.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec4}
+\NormalTok{puts vec4 >> }\DecValTok{0}
+\NormalTok{puts vec4 >> }\DecValTok{4}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 11 22 33 14 25 36 17 28 39
+## 11.0
+## 25.0
+\end{verbatim}
+
+Note that indexing with `\textgreater{}\textgreater{}' starts at 0 and
+not at 1, also, we cannot do negative indexing.
+
+\hypertarget{accessing-r-variables}{%
+\section{Accessing R variables}\label{accessing-r-variables}}
+
+Galaaz allows Ruby to access variables created in R. For example, the
+`mtcars' data set is available in R and can be accessed from Ruby by
+using the `tilda' operator followed by the symbol for the variable, in
+this case `:mtcar'. In the code bellow method `outputs' is used to
+output the `mtcars' data set nicely formatted in HTML by use of the
+`kable' and `kable\_styling' functions. Method `outputs' is only
+available when used with `gknit'.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{outputs (~}\StringTok{:mtcars}\NormalTok{).kable.kable_styling}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{table}[H]
+\centering
+\begin{tabular}{l|r|r|r|r|r|r|r|r|r|r|r}
+\hline
+  & mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
+\hline
+Mazda RX4 & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.620 & 16.46 & 0 & 1 & 4 & 4\\
+\hline
+Mazda RX4 Wag & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.875 & 17.02 & 0 & 1 & 4 & 4\\
+\hline
+Datsun 710 & 22.8 & 4 & 108.0 & 93 & 3.85 & 2.320 & 18.61 & 1 & 1 & 4 & 1\\
+\hline
+Hornet 4 Drive & 21.4 & 6 & 258.0 & 110 & 3.08 & 3.215 & 19.44 & 1 & 0 & 3 & 1\\
+\hline
+Hornet Sportabout & 18.7 & 8 & 360.0 & 175 & 3.15 & 3.440 & 17.02 & 0 & 0 & 3 & 2\\
+\hline
+Valiant & 18.1 & 6 & 225.0 & 105 & 2.76 & 3.460 & 20.22 & 1 & 0 & 3 & 1\\
+\hline
+Duster 360 & 14.3 & 8 & 360.0 & 245 & 3.21 & 3.570 & 15.84 & 0 & 0 & 3 & 4\\
+\hline
+Merc 240D & 24.4 & 4 & 146.7 & 62 & 3.69 & 3.190 & 20.00 & 1 & 0 & 4 & 2\\
+\hline
+Merc 230 & 22.8 & 4 & 140.8 & 95 & 3.92 & 3.150 & 22.90 & 1 & 0 & 4 & 2\\
+\hline
+Merc 280 & 19.2 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.30 & 1 & 0 & 4 & 4\\
+\hline
+Merc 280C & 17.8 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.90 & 1 & 0 & 4 & 4\\
+\hline
+Merc 450SE & 16.4 & 8 & 275.8 & 180 & 3.07 & 4.070 & 17.40 & 0 & 0 & 3 & 3\\
+\hline
+Merc 450SL & 17.3 & 8 & 275.8 & 180 & 3.07 & 3.730 & 17.60 & 0 & 0 & 3 & 3\\
+\hline
+Merc 450SLC & 15.2 & 8 & 275.8 & 180 & 3.07 & 3.780 & 18.00 & 0 & 0 & 3 & 3\\
+\hline
+Cadillac Fleetwood & 10.4 & 8 & 472.0 & 205 & 2.93 & 5.250 & 17.98 & 0 & 0 & 3 & 4\\
+\hline
+Lincoln Continental & 10.4 & 8 & 460.0 & 215 & 3.00 & 5.424 & 17.82 & 0 & 0 & 3 & 4\\
+\hline
+Chrysler Imperial & 14.7 & 8 & 440.0 & 230 & 3.23 & 5.345 & 17.42 & 0 & 0 & 3 & 4\\
+\hline
+Fiat 128 & 32.4 & 4 & 78.7 & 66 & 4.08 & 2.200 & 19.47 & 1 & 1 & 4 & 1\\
+\hline
+Honda Civic & 30.4 & 4 & 75.7 & 52 & 4.93 & 1.615 & 18.52 & 1 & 1 & 4 & 2\\
+\hline
+Toyota Corolla & 33.9 & 4 & 71.1 & 65 & 4.22 & 1.835 & 19.90 & 1 & 1 & 4 & 1\\
+\hline
+Toyota Corona & 21.5 & 4 & 120.1 & 97 & 3.70 & 2.465 & 20.01 & 1 & 0 & 3 & 1\\
+\hline
+Dodge Challenger & 15.5 & 8 & 318.0 & 150 & 2.76 & 3.520 & 16.87 & 0 & 0 & 3 & 2\\
+\hline
+AMC Javelin & 15.2 & 8 & 304.0 & 150 & 3.15 & 3.435 & 17.30 & 0 & 0 & 3 & 2\\
+\hline
+Camaro Z28 & 13.3 & 8 & 350.0 & 245 & 3.73 & 3.840 & 15.41 & 0 & 0 & 3 & 4\\
+\hline
+Pontiac Firebird & 19.2 & 8 & 400.0 & 175 & 3.08 & 3.845 & 17.05 & 0 & 0 & 3 & 2\\
+\hline
+Fiat X1-9 & 27.3 & 4 & 79.0 & 66 & 4.08 & 1.935 & 18.90 & 1 & 1 & 4 & 1\\
+\hline
+Porsche 914-2 & 26.0 & 4 & 120.3 & 91 & 4.43 & 2.140 & 16.70 & 0 & 1 & 5 & 2\\
+\hline
+Lotus Europa & 30.4 & 4 & 95.1 & 113 & 3.77 & 1.513 & 16.90 & 1 & 1 & 5 & 2\\
+\hline
+Ford Pantera L & 15.8 & 8 & 351.0 & 264 & 4.22 & 3.170 & 14.50 & 0 & 1 & 5 & 4\\
+\hline
+Ferrari Dino & 19.7 & 6 & 145.0 & 175 & 3.62 & 2.770 & 15.50 & 0 & 1 & 5 & 6\\
+\hline
+Maserati Bora & 15.0 & 8 & 301.0 & 335 & 3.54 & 3.570 & 14.60 & 0 & 1 & 5 & 8\\
+\hline
+Volvo 142E & 21.4 & 4 & 121.0 & 109 & 4.11 & 2.780 & 18.60 & 1 & 1 & 4 & 2\\
+\hline
+\end{tabular}
+\end{table}
+
+\hypertarget{matrix}{%
+\section{Matrix}\label{matrix}}
+
+A matrix is a collection of elements organized as a two dimensional
+table. A matrix can be created by the `matrix' function:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{mat = R.matrix(R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{, }\FloatTok{7.0}\NormalTok{, }\FloatTok{8.0}\NormalTok{, }\FloatTok{9.0}\NormalTok{),}
+               \StringTok{nrow: }\DecValTok{3}\NormalTok{,}
+               \StringTok{ncol: }\DecValTok{3}\NormalTok{)}
+
+\NormalTok{puts mat}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      [,1] [,2] [,3]
+## [1,]    1    4    7
+## [2,]    2    5    8
+## [3,]    3    6    9
+\end{verbatim}
+
+Note that matrices data is organized by column first. It is possible to
+organize the matrix memory by row first passing an extra argument to the
+`matrix' function:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{mat_row = R.matrix(R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{, }\FloatTok{7.0}\NormalTok{, }\FloatTok{8.0}\NormalTok{, }\FloatTok{9.0}\NormalTok{),}
+                   \StringTok{nrow: }\DecValTok{3}\NormalTok{,}
+                   \StringTok{ncol: }\DecValTok{3}\NormalTok{,}
+                   \StringTok{byrow: }\DecValTok{true}\NormalTok{)}
+
+\NormalTok{puts mat_row}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      [,1] [,2] [,3]
+## [1,]    1    2    3
+## [2,]    4    5    6
+## [3,]    7    8    9
+\end{verbatim}
+
+\hypertarget{indexing-a-matrix}{%
+\subsection{Indexing a Matrix}\label{indexing-a-matrix}}
+
+A matrix can be indexed by {[}row, column{]}:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts mat_row[}\DecValTok{1}\NormalTok{, }\DecValTok{1}\NormalTok{]}
+\NormalTok{puts mat_row[}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1
+## [1] 6
+\end{verbatim}
+
+It is possible to index an entire row or column with the `:all' keyword
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts mat_row[}\DecValTok{1}\NormalTok{, }\StringTok{:all}\NormalTok{]}
+\NormalTok{puts mat_row[}\StringTok{:all}\NormalTok{, }\DecValTok{2}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3
+## [1] 2 5 8
+\end{verbatim}
+
+Indexing with a vector is also possible for matrices. In the following
+example we want rows 1 and 3 and columns 2 and 3 building a 2 x 2
+matrix.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts mat_row[R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{), R.c(}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      [,1] [,2]
+## [1,]    2    3
+## [2,]    8    9
+\end{verbatim}
+
+Matrices can be combined with functions `rbind':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts mat_row.rbind(mat)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      [,1] [,2] [,3]
+## [1,]    1    2    3
+## [2,]    4    5    6
+## [3,]    7    8    9
+## [4,]    1    4    7
+## [5,]    2    5    8
+## [6,]    3    6    9
+\end{verbatim}
+
+and `cbind':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts mat_row.cbind(mat)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      [,1] [,2] [,3] [,4] [,5] [,6]
+## [1,]    1    2    3    1    4    7
+## [2,]    4    5    6    2    5    8
+## [3,]    7    8    9    3    6    9
+\end{verbatim}
+
+\hypertarget{list}{%
+\section{List}\label{list}}
+
+A list is a data structure that can contain sublists of different types,
+while vector and matrix can only hold one type of element.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{nums = R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{)}
+\NormalTok{strs = R.c(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{, }\StringTok{"d"}\NormalTok{)}
+\NormalTok{bool = R.c(}\DecValTok{true}\NormalTok{, }\DecValTok{true}\NormalTok{, }\DecValTok{false}\NormalTok{)}
+\NormalTok{lst = R.list(}\StringTok{nums: }\NormalTok{nums, }\StringTok{strs: }\NormalTok{strs, }\StringTok{bool: }\NormalTok{bool)}
+\NormalTok{puts lst}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## $nums
+## [1] 1 2 3
+## 
+## $strs
+## [1] "a" "b" "c" "d"
+## 
+## $bool
+## [1]  TRUE  TRUE FALSE
+\end{verbatim}
+
+Note that `lst' elements are named elements.
+
+\hypertarget{list-indexing}{%
+\subsection{List Indexing}\label{list-indexing}}
+
+List indexing, also called slicing, is done using the `{[}{]}' operator
+and the `{[}{[}{]}{]}' operator. Let's first start with the `{[}{]}'
+operator. The list above has three sublist indexing with `{[}{]}' will
+return one of the sublists.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts lst[}\DecValTok{1}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## $nums
+## [1] 1 2 3
+\end{verbatim}
+
+Note that when using `{[}{]}' a new list is returned. When using the
+double square bracket operator the value returned is the actual element
+of the list in the given position and not a slice of the original list
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts lst[[}\DecValTok{1}\NormalTok{]]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3
+\end{verbatim}
+
+When elements are named, as dones with lst, indexing can be done by
+name:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts lst[[}\StringTok{'bool'}\NormalTok{]][[}\DecValTok{1}\NormalTok{]] >> }\DecValTok{0}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## true
+\end{verbatim}
+
+In this example, first the `bool' element of the list was extracted, not
+as a list, but as a vector, then the first element of the vector was
+extracted (note that vectors also accept the `{[}{[}{]}{]}' operator)
+and then the vector was indexed by its first element, extracting the
+native Ruby type.
+
+\hypertarget{data-frame}{%
+\section{Data Frame}\label{data-frame}}
+
+A data frame is a table like structure in which each column has the same
+number of rows. Data frames are the basic structure for storing data for
+data analysis. We have already seen a data frame previously when we
+accessed variable `\textasciitilde{}:mtcars'. In order to create a data
+frame, function 'data\_\_frame' is used:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df = R.data__frame(}
+  \StringTok{year: }\NormalTok{R.c(}\DecValTok{2010}\NormalTok{, }\DecValTok{2011}\NormalTok{, }\DecValTok{2012}\NormalTok{),}
+  \StringTok{income: }\NormalTok{R.c(}\FloatTok{1000.0}\NormalTok{, }\FloatTok{1500.0}\NormalTok{, }\FloatTok{2000.0}\NormalTok{))}
+
+\NormalTok{puts df}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year income
+## 1 2010   1000
+## 2 2011   1500
+## 3 2012   2000
+\end{verbatim}
+
+\hypertarget{data-frame-indexing}{%
+\subsection{Data Frame Indexing}\label{data-frame-indexing}}
+
+A data frame can be indexed the same way as a matrix, by using `{[}row,
+column{]}', where row and column can either be a numeric or the name of
+the row or column
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{).head}
+\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{]}
+\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[}\StringTok{'Datsun 710'}\NormalTok{, }\StringTok{'mpg'}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##                    mpg cyl disp  hp drat    wt  qsec vs am gear carb
+## Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
+## Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
+## Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
+## Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
+## Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
+## Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1
+## [1] 6
+## [1] 22.8
+\end{verbatim}
+
+Extracting a column from a data frame as a vector can be done by using
+the double square bracket operator:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[[}\StringTok{'mpg'}\NormalTok{]]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##  [1] 21.0 21.0 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 17.8 16.4 17.3 15.2
+## [15] 10.4 10.4 14.7 32.4 30.4 33.9 21.5 15.5 15.2 13.3 19.2 27.3 26.0 30.4
+## [29] 15.8 19.7 15.0 21.4
+\end{verbatim}
+
+A data frame column can also be accessed as if it were an instance
+variable of the data frame:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{).mpg}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##  [1] 21.0 21.0 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 17.8 16.4 17.3 15.2
+## [15] 10.4 10.4 14.7 32.4 30.4 33.9 21.5 15.5 15.2 13.3 19.2 27.3 26.0 30.4
+## [29] 15.8 19.7 15.0 21.4
+\end{verbatim}
+
+Slicing a data frame can be done by indexing it with a vector (we use
+`head' to reduce the output):
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[R.c(}\StringTok{'mpg'}\NormalTok{, }\StringTok{'hp'}\NormalTok{)].head}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##                    mpg  hp
+## Mazda RX4         21.0 110
+## Mazda RX4 Wag     21.0 110
+## Datsun 710        22.8  93
+## Hornet 4 Drive    21.4 110
+## Hornet Sportabout 18.7 175
+## Valiant           18.1 105
+\end{verbatim}
+
+A row slice can be obtained by indexing by row and using the `:all'
+keyword for the column:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[R.c(}\StringTok{'Datsun 710'}\NormalTok{, }\StringTok{'Camaro Z28'}\NormalTok{), }\StringTok{:all}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##             mpg cyl disp  hp drat   wt  qsec vs am gear carb
+## Datsun 710 22.8   4  108  93 3.85 2.32 18.61  1  1    4    1
+## Camaro Z28 13.3   8  350 245 3.73 3.84 15.41  0  0    3    4
+\end{verbatim}
+
+Finally, a data frame can also be indexed with a logical vector. In this
+next example, the `am' column of :mtcars is compared with 0 (with method
+`eq'). When `am' is equal to 0 the car is automatic. So, by doing
+`(\textasciitilde{}:mtcars).am.eq 0' a logical vector is created with
+`true' whenever `am' is 0 and `false' otherwise.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# obtain a vector with 'true' for cars with automatic transmission}
+\NormalTok{automatic = (~}\StringTok{:mtcars}\NormalTok{).am.eq }\DecValTok{0}
+\NormalTok{puts automatic}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##  [1] FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
+## [12]  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE  TRUE  TRUE
+## [23]  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
+\end{verbatim}
+
+Using this logical vector, the data frame is indexed, returning a new
+data frame in which all cars have automatic transmission.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# slice the data frame by using this vector}
+\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[automatic, }\StringTok{:all}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##                      mpg cyl  disp  hp drat    wt  qsec vs am gear carb
+## Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
+## Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
+## Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
+## Duster 360          14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
+## Merc 240D           24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2
+## Merc 230            22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2
+## Merc 280            19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4
+## Merc 280C           17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4
+## Merc 450SE          16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3
+## Merc 450SL          17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3
+## Merc 450SLC         15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3
+## Cadillac Fleetwood  10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4
+## Lincoln Continental 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4
+## Chrysler Imperial   14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4
+## Toyota Corona       21.5   4 120.1  97 3.70 2.465 20.01  1  0    3    1
+## Dodge Challenger    15.5   8 318.0 150 2.76 3.520 16.87  0  0    3    2
+## AMC Javelin         15.2   8 304.0 150 3.15 3.435 17.30  0  0    3    2
+## Camaro Z28          13.3   8 350.0 245 3.73 3.840 15.41  0  0    3    4
+## Pontiac Firebird    19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2
+\end{verbatim}
+
+\hypertarget{writing-expressions-in-galaaz}{%
+\section{Writing Expressions in
+Galaaz}\label{writing-expressions-in-galaaz}}
+
+Galaaz extends Ruby to work with complex expressions, similar to R's
+expressions build with `quote' (base R) or `quo' (tidyverse). Let's take
+a look at some of those expressions.
+
+\hypertarget{expressions-from-operators}{%
+\subsection{Expressions from
+operators}\label{expressions-from-operators}}
+
+The code bellow creates an expression summing two symbols
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp1 = }\StringTok{:a}\NormalTok{ + }\StringTok{:b}
+\NormalTok{puts exp1}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b
+\end{verbatim}
+
+We can build any complex mathematical expression
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp2 = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) * }\FloatTok{2.0}\NormalTok{ + }\StringTok{:c}\NormalTok{ ** }\DecValTok{2}\NormalTok{ / }\StringTok{:z}
+\NormalTok{puts exp2}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## (a + b) * 2 + c^2L/z
+\end{verbatim}
+
+It is also possible to use inequality operators in building expressions
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp3 = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) >= }\StringTok{:z}
+\NormalTok{puts exp3}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b >= z
+\end{verbatim}
+
+Galaaz provides both symbolic representations for operators, such as
+(\textgreater{}, \textless{}, !=) as functional notation for those
+operators such as (.gt, .ge, etc.). So the same expression written above
+can also be written as
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp4 = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{).ge }\StringTok{:z}
+\NormalTok{puts exp4}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b >= z
+\end{verbatim}
+
+Two type of expression can only be created with the functional
+representation of the operators, those are expressions involving `==',
+and `='. In order to write an expression involving `==' we need to use
+the method `.eq' and for `=' we need the function `.assign'
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp5 = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{).eq }\StringTok{:z}
+\NormalTok{puts exp5}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b == z
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp6 = }\StringTok{:y}\NormalTok{.assign }\StringTok{:a}\NormalTok{ + }\StringTok{:b}
+\NormalTok{puts exp6}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- a + b
+\end{verbatim}
+
+In general we think that using the functional notation is preferable to
+using the symbolic notation as otherwise, we end up writing invalid
+expressions such as
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp_wrong = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) == }\StringTok{:z}
+\NormalTok{puts exp_wrong}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Message:
+##  Error in function (x, y, num.eq = TRUE, single.NA = TRUE, attrib.as.set = TRUE,  :
+##   object 'a' not found (RError)
+## Translated to internal error
+\end{verbatim}
+
+and it might be difficult to understand what is going on here. The
+problem lies with the fact that when using `==' we are comparing
+expression (:a + :b) to expression :z with `=='. When the comparison is
+executed, the system tries to evaluate :a, :b and :z, and those symbols
+at this time are not bound to anything and we get a ``object `a' not
+found'' message. If we only use functional notation, this type of error
+will not occur.
+
+\hypertarget{expressions-with-r-methods}{%
+\subsection{Expressions with R
+methods}\label{expressions-with-r-methods}}
+
+It is often necessary to create an expression that uses a method or
+function. For instance, in mathematics, it's quite natural to write an
+expressin such as \(y = sin(x)\). In this case, the `sin' function is
+part of the expression and should not immediately executed. Now, let's
+say that `x' is an angle of 45\(^\circ\) and we acttually want our
+expression to be \(y = 0.850...\). When we want the function to be part
+of the expression, we call the function preceeding it by the letter E,
+such as `E.sin(x)'
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp7 = }\StringTok{:y}\NormalTok{.assign E.sin(}\StringTok{:x}\NormalTok{)}
+\NormalTok{puts exp7}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- sin(x)
+\end{verbatim}
+
+Expressions can also be written using `.' notation:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp8 = }\StringTok{:y}\NormalTok{.assign }\StringTok{:x}\NormalTok{.sin}
+\NormalTok{puts exp8}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- sin(x)
+\end{verbatim}
+
+When a function has multiple arguments, the first one can be used before
+the `.':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp9 = }\StringTok{:x}\NormalTok{.c(}\StringTok{:y}\NormalTok{)}
+\NormalTok{puts exp9}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## c(x, y)
+\end{verbatim}
+
+\hypertarget{evaluating-an-expression}{%
+\subsection{Evaluating an Expression}\label{evaluating-an-expression}}
+
+Expressions can be evaluated by calling function `eval' with a binding.
+A binding can be provided with a list:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) * }\FloatTok{2.0}\NormalTok{ + }\StringTok{:c}\NormalTok{ ** }\DecValTok{2}\NormalTok{ / }\StringTok{:z}
+\NormalTok{puts exp.eval(R.list(}\StringTok{a: }\DecValTok{10}\NormalTok{, }\StringTok{b: }\DecValTok{20}\NormalTok{, }\StringTok{c: }\DecValTok{30}\NormalTok{, }\StringTok{z: }\DecValTok{40}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 82.5
+\end{verbatim}
+
+\ldots{} with a data frame:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df = R.data__frame(}
+  \StringTok{a: }\NormalTok{R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{),}
+  \StringTok{b: }\NormalTok{R.c(}\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{),}
+  \StringTok{c: }\NormalTok{R.c(}\DecValTok{100}\NormalTok{, }\DecValTok{200}\NormalTok{, }\DecValTok{300}\NormalTok{),}
+  \StringTok{z: }\NormalTok{R.c(}\DecValTok{1000}\NormalTok{, }\DecValTok{2000}\NormalTok{, }\DecValTok{3000}\NormalTok{))}
+
+\NormalTok{puts exp.eval(df)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 32 64 96
+\end{verbatim}
+
+\hypertarget{manipulating-data}{%
+\section{Manipulating Data}\label{manipulating-data}}
+
+One of the major benefits of Galaaz is to bring strong data manipulation
+to Ruby. The following examples were extracted from Hardley's ``R for
+Data Science'' (\url{https://r4ds.had.co.nz/}). This is a highly
+recommended book for those not already familiar with the `tidyverse'
+style of programming in R. In the sections to follow, we will limit
+ourselves to convert the R code to Galaaz.
+
+For these examples, we will investigate the nycflights13 data set
+available on the package by the same name. We use function
+`R.install\_and\_loads' that checks if the library is available locally,
+and if not, installs it. This data frame contains all 336,776 flights
+that departed from New York City in 2013. The data comes from the US
+Bureau of Transportation Statistics.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{R.install_and_loads(}\StringTok{'nycflights13'}\NormalTok{)}
+\NormalTok{R.library(}\StringTok{'dplyr'}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{flights = ~}\StringTok{:flights}
+\NormalTok{puts flights.head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+## 1 2013     1   1      517            515         2      830            819
+## 2 2013     1   1      533            529         4      850            830
+## 3 2013     1   1      542            540         2      923            850
+## 4 2013     1   1      544            545        -1     1004           1022
+## 5 2013     1   1      554            600        -6      812            837
+## 6 2013     1   1      554            558        -4      740            728
+##   arr_delay carrier flight tailnum origin dest air_time distance hour
+## 1        11      UA   1545  N14228    EWR  IAH      227     1400    5
+## 2        20      UA   1714  N24211    LGA  IAH      227     1416    5
+## 3        33      AA   1141  N619AA    JFK  MIA      160     1089    5
+## 4       -18      B6    725  N804JB    JFK  BQN      183     1576    5
+## 5       -25      DL    461  N668DN    LGA  ATL      116      762    6
+## 6        12      UA   1696  N39463    EWR  ORD      150      719    5
+##   minute           time_hour
+## 1     15 2013-01-01 05:00:00
+## 2     29 2013-01-01 05:00:00
+## 3     40 2013-01-01 05:00:00
+## 4     45 2013-01-01 05:00:00
+## 5      0 2013-01-01 06:00:00
+## 6     58 2013-01-01 05:00:00
+\end{verbatim}
+
+\hypertarget{filtering-rows-with-filter}{%
+\subsection{Filtering rows with
+Filter}\label{filtering-rows-with-filter}}
+
+In this example we filter the flights data set by giving to the filter
+function two expressions: the first :month.eq 1
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.filter((}\StringTok{:month}\NormalTok{.eq }\DecValTok{1}\NormalTok{), (}\StringTok{:day}\NormalTok{.eq }\DecValTok{1}\NormalTok{)).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+## 1 2013     1   1      517            515         2      830            819
+## 2 2013     1   1      533            529         4      850            830
+## 3 2013     1   1      542            540         2      923            850
+## 4 2013     1   1      544            545        -1     1004           1022
+## 5 2013     1   1      554            600        -6      812            837
+## 6 2013     1   1      554            558        -4      740            728
+##   arr_delay carrier flight tailnum origin dest air_time distance hour
+## 1        11      UA   1545  N14228    EWR  IAH      227     1400    5
+## 2        20      UA   1714  N24211    LGA  IAH      227     1416    5
+## 3        33      AA   1141  N619AA    JFK  MIA      160     1089    5
+## 4       -18      B6    725  N804JB    JFK  BQN      183     1576    5
+## 5       -25      DL    461  N668DN    LGA  ATL      116      762    6
+## 6        12      UA   1696  N39463    EWR  ORD      150      719    5
+##   minute           time_hour
+## 1     15 2013-01-01 05:00:00
+## 2     29 2013-01-01 05:00:00
+## 3     40 2013-01-01 05:00:00
+## 4     45 2013-01-01 05:00:00
+## 5      0 2013-01-01 06:00:00
+## 6     58 2013-01-01 05:00:00
+\end{verbatim}
+
+\hypertarget{logical-operators}{%
+\subsection{Logical Operators}\label{logical-operators}}
+
+All flights that departed in November of December
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.filter((}\StringTok{:month}\NormalTok{.eq }\DecValTok{11}\NormalTok{) | (}\StringTok{:month}\NormalTok{.eq }\DecValTok{12}\NormalTok{)).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+## 1 2013    11   1        5           2359         6      352            345
+## 2 2013    11   1       35           2250       105      123           2356
+## 3 2013    11   1      455            500        -5      641            651
+## 4 2013    11   1      539            545        -6      856            827
+## 5 2013    11   1      542            545        -3      831            855
+## 6 2013    11   1      549            600       -11      912            923
+##   arr_delay carrier flight tailnum origin dest air_time distance hour
+## 1         7      B6    745  N568JB    JFK  PSE      205     1617   23
+## 2        87      B6   1816  N353JB    JFK  SYR       36      209   22
+## 3       -10      US   1895  N192UW    EWR  CLT       88      529    5
+## 4        29      UA   1714  N38727    LGA  IAH      229     1416    5
+## 5       -24      AA   2243  N5CLAA    JFK  MIA      147     1089    5
+## 6       -11      UA    303  N595UA    JFK  SFO      359     2586    6
+##   minute           time_hour
+## 1     59 2013-11-01 23:00:00
+## 2     50 2013-11-01 22:00:00
+## 3      0 2013-11-01 05:00:00
+## 4     45 2013-11-01 05:00:00
+## 5     45 2013-11-01 05:00:00
+## 6      0 2013-11-01 06:00:00
+\end{verbatim}
+
+The same as above, but using the `in' operator. In R, it is possible to
+define many operators by doing \%\%. The \%in\% operator checks if a
+value is in a vector. In order to use those operators from Galaaz the
+`.\_' method is used, where the first argument is the operator's symbol,
+in this case `:in' and the second argument is the vector:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.filter(}\StringTok{:month}\NormalTok{._ }\StringTok{:in}\NormalTok{, R.c(}\DecValTok{11}\NormalTok{, }\DecValTok{12}\NormalTok{)).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+## 1 2013    11   1        5           2359         6      352            345
+## 2 2013    11   1       35           2250       105      123           2356
+## 3 2013    11   1      455            500        -5      641            651
+## 4 2013    11   1      539            545        -6      856            827
+## 5 2013    11   1      542            545        -3      831            855
+## 6 2013    11   1      549            600       -11      912            923
+##   arr_delay carrier flight tailnum origin dest air_time distance hour
+## 1         7      B6    745  N568JB    JFK  PSE      205     1617   23
+## 2        87      B6   1816  N353JB    JFK  SYR       36      209   22
+## 3       -10      US   1895  N192UW    EWR  CLT       88      529    5
+## 4        29      UA   1714  N38727    LGA  IAH      229     1416    5
+## 5       -24      AA   2243  N5CLAA    JFK  MIA      147     1089    5
+## 6       -11      UA    303  N595UA    JFK  SFO      359     2586    6
+##   minute           time_hour
+## 1     59 2013-11-01 23:00:00
+## 2     50 2013-11-01 22:00:00
+## 3      0 2013-11-01 05:00:00
+## 4     45 2013-11-01 05:00:00
+## 5     45 2013-11-01 05:00:00
+## 6      0 2013-11-01 06:00:00
+\end{verbatim}
+
+\hypertarget{filtering-with-na-not-available}{%
+\subsection{Filtering with NA (Not
+Available)}\label{filtering-with-na-not-available}}
+
+Let's first create a `tibble' with a Not Available value (R::NA).
+Tibbles are a modern version of a data frame and operate very similarly
+to one. It differs in how it outputs the values and the result of some
+subsetting operations that are more consistent than what is obtained
+from data frame.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df = R.tibble(}\StringTok{x: }\NormalTok{R.c(}\DecValTok{1}\NormalTok{, R::}\DataTypeTok{NA}\NormalTok{, }\DecValTok{3}\NormalTok{))}
+\NormalTok{puts df.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##    x
+## 1  1
+## 2 NA
+## 3  3
+\end{verbatim}
+
+Now filtering by :x \textgreater{} 1 shows all lines that satisfy this
+condition, where the row with R:NA does not.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts df.filter(}\StringTok{:x}\NormalTok{ > }\DecValTok{1}\NormalTok{).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x
+## 1 3
+\end{verbatim}
+
+To match an NA use method 'is\_\_na'
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts df.filter((}\StringTok{:x}\NormalTok{.is__na) | (}\StringTok{:x}\NormalTok{ > }\DecValTok{1}\NormalTok{)).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##    x
+## 1 NA
+## 2  3
+\end{verbatim}
+
+\hypertarget{arrange-rows-with-arrange}{%
+\subsection{Arrange Rows with arrange}\label{arrange-rows-with-arrange}}
+
+Arrange reorders the rows of a data frame by the given arguments.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.arrange(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+## 1 2013     1   1      517            515         2      830            819
+## 2 2013     1   1      533            529         4      850            830
+## 3 2013     1   1      542            540         2      923            850
+## 4 2013     1   1      544            545        -1     1004           1022
+## 5 2013     1   1      554            600        -6      812            837
+## 6 2013     1   1      554            558        -4      740            728
+##   arr_delay carrier flight tailnum origin dest air_time distance hour
+## 1        11      UA   1545  N14228    EWR  IAH      227     1400    5
+## 2        20      UA   1714  N24211    LGA  IAH      227     1416    5
+## 3        33      AA   1141  N619AA    JFK  MIA      160     1089    5
+## 4       -18      B6    725  N804JB    JFK  BQN      183     1576    5
+## 5       -25      DL    461  N668DN    LGA  ATL      116      762    6
+## 6        12      UA   1696  N39463    EWR  ORD      150      719    5
+##   minute           time_hour
+## 1     15 2013-01-01 05:00:00
+## 2     29 2013-01-01 05:00:00
+## 3     40 2013-01-01 05:00:00
+## 4     45 2013-01-01 05:00:00
+## 5      0 2013-01-01 06:00:00
+## 6     58 2013-01-01 05:00:00
+\end{verbatim}
+
+To arrange in descending order, use function `desc'
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.arrange(}\StringTok{:dep_delay}\NormalTok{.desc).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+## 1 2013     1   9      641            900      1301     1242           1530
+## 2 2013     6  15     1432           1935      1137     1607           2120
+## 3 2013     1  10     1121           1635      1126     1239           1810
+## 4 2013     9  20     1139           1845      1014     1457           2210
+## 5 2013     7  22      845           1600      1005     1044           1815
+## 6 2013     4  10     1100           1900       960     1342           2211
+##   arr_delay carrier flight tailnum origin dest air_time distance hour
+## 1      1272      HA     51  N384HA    JFK  HNL      640     4983    9
+## 2      1127      MQ   3535  N504MQ    JFK  CMH       74      483   19
+## 3      1109      MQ   3695  N517MQ    EWR  ORD      111      719   16
+## 4      1007      AA    177  N338AA    JFK  SFO      354     2586   18
+## 5       989      MQ   3075  N665MQ    JFK  CVG       96      589   16
+## 6       931      DL   2391  N959DL    JFK  TPA      139     1005   19
+##   minute           time_hour
+## 1      0 2013-01-09 09:00:00
+## 2     35 2013-06-15 19:00:00
+## 3     35 2013-01-10 16:00:00
+## 4     45 2013-09-20 18:00:00
+## 5      0 2013-07-22 16:00:00
+## 6      0 2013-04-10 19:00:00
+\end{verbatim}
+
+\hypertarget{selecting-columns}{%
+\subsection{Selecting columns}\label{selecting-columns}}
+
+To select specific columns from a dataset we use function `select':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day
+## 1 2013     1   1
+## 2 2013     1   1
+## 3 2013     1   1
+## 4 2013     1   1
+## 5 2013     1   1
+## 6 2013     1   1
+\end{verbatim}
+
+It is also possible to select column in a given range
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{.up_to }\StringTok{:day}\NormalTok{).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day
+## 1 2013     1   1
+## 2 2013     1   1
+## 3 2013     1   1
+## 4 2013     1   1
+## 5 2013     1   1
+## 6 2013     1   1
+\end{verbatim}
+
+Select all columns that start with a given name sequence
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.select(E.starts_with(}\StringTok{'arr'}\NormalTok{)).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   arr_time arr_delay
+## 1      830        11
+## 2      850        20
+## 3      923        33
+## 4     1004       -18
+## 5      812       -25
+## 6      740        12
+\end{verbatim}
+
+Other functions that can be used:
+
+\begin{itemize}
+\item
+  ends\_with(``xyz''): matches names that end with ``xyz''.
+\item
+  contains(``ijk''): matches names that contain ``ijk''.
+\item
+  matches(``(.)\textbackslash{}1''): selects variables that match a
+  regular expression. This one matches any variables that contain
+  repeated characters.
+\item
+  num\_range(``x'', (1..3)): matches x1, x2 and x3
+\end{itemize}
+
+A helper function that comes in handy when we just want to rearrange
+column order is `Everything':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{, E.everything).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+## 1 2013     1   1      517            515         2      830            819
+## 2 2013     1   1      533            529         4      850            830
+## 3 2013     1   1      542            540         2      923            850
+## 4 2013     1   1      544            545        -1     1004           1022
+## 5 2013     1   1      554            600        -6      812            837
+## 6 2013     1   1      554            558        -4      740            728
+##   arr_delay carrier flight tailnum origin dest air_time distance hour
+## 1        11      UA   1545  N14228    EWR  IAH      227     1400    5
+## 2        20      UA   1714  N24211    LGA  IAH      227     1416    5
+## 3        33      AA   1141  N619AA    JFK  MIA      160     1089    5
+## 4       -18      B6    725  N804JB    JFK  BQN      183     1576    5
+## 5       -25      DL    461  N668DN    LGA  ATL      116      762    6
+## 6        12      UA   1696  N39463    EWR  ORD      150      719    5
+##   minute           time_hour
+## 1     15 2013-01-01 05:00:00
+## 2     29 2013-01-01 05:00:00
+## 3     40 2013-01-01 05:00:00
+## 4     45 2013-01-01 05:00:00
+## 5      0 2013-01-01 06:00:00
+## 6     58 2013-01-01 05:00:00
+\end{verbatim}
+
+\hypertarget{add-variables-to-a-dataframe-with-mutate}{%
+\subsection{Add variables to a dataframe with
+`mutate'}\label{add-variables-to-a-dataframe-with-mutate}}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{flights_sm = flights.}
+\NormalTok{               select((}\StringTok{:year}\NormalTok{.up_to }\StringTok{:day}\NormalTok{),}
+\NormalTok{                      E.ends_with(}\StringTok{'delay'}\NormalTok{),}
+                      \StringTok{:distance}\NormalTok{,}
+                      \StringTok{:air_time}\NormalTok{)}
+
+\NormalTok{puts flights_sm.head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day dep_delay arr_delay distance air_time
+## 1 2013     1   1         2        11     1400      227
+## 2 2013     1   1         4        20     1416      227
+## 3 2013     1   1         2        33     1089      160
+## 4 2013     1   1        -1       -18     1576      183
+## 5 2013     1   1        -6       -25      762      116
+## 6 2013     1   1        -4        12      719      150
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{flights_sm = flights_sm.}
+\NormalTok{               mutate(}\StringTok{gain: :dep_delay}\NormalTok{ - }\StringTok{:arr_delay}\NormalTok{,}
+                      \StringTok{speed: :distance}\NormalTok{ / }\StringTok{:air_time}\NormalTok{ * }\DecValTok{60}\NormalTok{)}
+\NormalTok{puts flights_sm.head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day dep_delay arr_delay distance air_time gain    speed
+## 1 2013     1   1         2        11     1400      227   -9 370.0441
+## 2 2013     1   1         4        20     1416      227  -16 374.2731
+## 3 2013     1   1         2        33     1089      160  -31 408.3750
+## 4 2013     1   1        -1       -18     1576      183   17 516.7213
+## 5 2013     1   1        -6       -25      762      116   19 394.1379
+## 6 2013     1   1        -4        12      719      150  -16 287.6000
+\end{verbatim}
+
+\hypertarget{summarising-data}{%
+\subsection{Summarising data}\label{summarising-data}}
+
+Function `summarise' calculates summaries for the data frame. When no
+`group\_by' is used a single value is obtained from the data frame:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts flights.summarise(}\StringTok{delay: }\NormalTok{E.mean(}\StringTok{:dep_delay}\NormalTok{, }\StringTok{na__rm: }\DecValTok{true}\NormalTok{)).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      delay
+## 1 12.63907
+\end{verbatim}
+
+When a data frame is groupe with `group\_by' summaries apply to the
+given group:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{by_day = flights.group_by(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{)}
+\NormalTok{puts by_day.summarise(}\StringTok{delay: :dep_delay}\NormalTok{.mean(}\StringTok{na__rm: }\DecValTok{true}\NormalTok{)).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   year month day     delay
+## 1 2013     1   1 11.548926
+## 2 2013     1   2 13.858824
+## 3 2013     1   3 10.987832
+## 4 2013     1   4  8.951595
+## 5 2013     1   5  5.732218
+## 6 2013     1   6  7.148014
+\end{verbatim}
+
+Next we put many operations together by pipping them one after the
+other:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{delays = flights.}
+\NormalTok{           group_by(}\StringTok{:dest}\NormalTok{).}
+\NormalTok{           summarise(}
+             \StringTok{count: }\NormalTok{E.n,}
+             \StringTok{dist: :distance}\NormalTok{.mean(}\StringTok{na__rm: }\DecValTok{true}\NormalTok{),}
+             \StringTok{delay: :arr_delay}\NormalTok{.mean(}\StringTok{na__rm: }\DecValTok{true}\NormalTok{)).}
+\NormalTok{           filter(}\StringTok{:count}\NormalTok{ > }\DecValTok{20}\NormalTok{, }\StringTok{:dest}\NormalTok{ != }\StringTok{"NHL"}\NormalTok{)}
+
+\NormalTok{puts delays.as__data__frame.head}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   dest count      dist     delay
+## 1  ABQ   254 1826.0000  4.381890
+## 2  ACK   265  199.0000  4.852273
+## 3  ALB   439  143.0000 14.397129
+## 4  ATL 17215  757.1082 11.300113
+## 5  AUS  2439 1514.2530  6.019909
+## 6  AVL   275  583.5818  8.003831
+\end{verbatim}
+
+\hypertarget{using-data-table}{%
+\section{Using Data Table}\label{using-data-table}}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{R.library(}\StringTok{'data.table'}\NormalTok{)}
+\NormalTok{R.install_and_loads(}\StringTok{'curl'}\NormalTok{)}
+
+\NormalTok{input = }\StringTok{"https://raw.githubusercontent.com/Rdatatable/data.table/master/vignettes/flights14.csv"}
+\NormalTok{flights = R.fread(input)}
+\NormalTok{puts flights}
+\NormalTok{puts flights.dim}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##         year month day dep_delay arr_delay carrier origin dest air_time
+##      1: 2014     1   1        14        13      AA    JFK  LAX      359
+##      2: 2014     1   1        -3        13      AA    JFK  LAX      363
+##      3: 2014     1   1         2         9      AA    JFK  LAX      351
+##      4: 2014     1   1        -8       -26      AA    LGA  PBI      157
+##      5: 2014     1   1         2         1      AA    JFK  LAX      350
+##     ---                                                                
+## 253312: 2014    10  31         1       -30      UA    LGA  IAH      201
+## 253313: 2014    10  31        -5       -14      UA    EWR  IAH      189
+## 253314: 2014    10  31        -8        16      MQ    LGA  RDU       83
+## 253315: 2014    10  31        -4        15      MQ    LGA  DTW       75
+## 253316: 2014    10  31        -5         1      MQ    LGA  SDF      110
+##         distance hour
+##      1:     2475    9
+##      2:     2475   11
+##      3:     2475   19
+##      4:     1035    7
+##      5:     2475   13
+##     ---              
+## 253312:     1416   14
+## 253313:     1400    8
+## 253314:      431   11
+## 253315:      502   11
+## 253316:      659    8
+## [1] 253316     11
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+
+\NormalTok{data_table = R.data__table(}
+  \DataTypeTok{ID}\NormalTok{: R.c(}\StringTok{"b"}\NormalTok{,}\StringTok{"b"}\NormalTok{,}\StringTok{"b"}\NormalTok{,}\StringTok{"a"}\NormalTok{,}\StringTok{"a"}\NormalTok{,}\StringTok{"c"}\NormalTok{),}
+  \StringTok{a: }\NormalTok{(}\DecValTok{1}\NormalTok{..}\DecValTok{6}\NormalTok{),}
+  \StringTok{b: }\NormalTok{(}\DecValTok{7}\NormalTok{..}\DecValTok{12}\NormalTok{),}
+  \StringTok{c: }\NormalTok{(}\DecValTok{13}\NormalTok{..}\DecValTok{18}\NormalTok{)}
+\NormalTok{)}
+
+\NormalTok{puts data_table}
+\NormalTok{puts data_table.}\DataTypeTok{ID}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##    ID a  b  c
+## 1:  b 1  7 13
+## 2:  b 2  8 14
+## 3:  b 3  9 15
+## 4:  a 4 10 16
+## 5:  a 5 11 17
+## 6:  c 6 12 18
+## [1] "b" "b" "b" "a" "a" "c"
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# subset rows in i}
+\NormalTok{ans = flights[(}\StringTok{:origin}\NormalTok{.eq }\StringTok{"JFK"}\NormalTok{) & (}\StringTok{:month}\NormalTok{.eq }\DecValTok{6}\NormalTok{)]}
+\NormalTok{puts ans.head}
+
+\CommentTok{# Get the first two rows from flights.}
+
+\NormalTok{ans = flights[(}\DecValTok{1}\NormalTok{..}\DecValTok{2}\NormalTok{)]}
+\NormalTok{puts ans}
+
+\CommentTok{# Sort flights first by column origin in ascending order, and then by dest in descending order:}
+
+\CommentTok{# ans = flights[E.order(:origin, -(:dest))]}
+\CommentTok{# puts ans.head}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##    year month day dep_delay arr_delay carrier origin dest air_time
+## 1: 2014     6   1        -9        -5      AA    JFK  LAX      324
+## 2: 2014     6   1       -10       -13      AA    JFK  LAX      329
+## 3: 2014     6   1        18        -1      AA    JFK  LAX      326
+## 4: 2014     6   1        -6       -16      AA    JFK  LAX      320
+## 5: 2014     6   1        -4       -45      AA    JFK  LAX      326
+## 6: 2014     6   1        -6       -23      AA    JFK  LAX      329
+##    distance hour
+## 1:     2475    8
+## 2:     2475   12
+## 3:     2475    7
+## 4:     2475   10
+## 5:     2475   18
+## 6:     2475   14
+##    year month day dep_delay arr_delay carrier origin dest air_time
+## 1: 2014     1   1        14        13      AA    JFK  LAX      359
+## 2: 2014     1   1        -3        13      AA    JFK  LAX      363
+##    distance hour
+## 1:     2475    9
+## 2:     2475   11
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# Select column(s) in j}
+\CommentTok{# select arr_delay column, but return it as a vector.}
+
+\NormalTok{ans = flights[}\StringTok{:all}\NormalTok{, }\StringTok{:arr_delay}\NormalTok{]}
+\NormalTok{puts ans.head}
+
+\CommentTok{# Select arr_delay column, but return as a data.table instead.}
+
+\NormalTok{ans = flights[}\StringTok{:all}\NormalTok{, }\StringTok{:arr_delay}\NormalTok{.list]}
+\NormalTok{puts ans.head}
+
+\NormalTok{ans = flights[}\StringTok{:all}\NormalTok{, E.list(}\StringTok{:arr_delay}\NormalTok{, }\StringTok{:dep_delay}\NormalTok{)]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1]  13  13   9 -26   1   0
+##    arr_delay
+## 1:        13
+## 2:        13
+## 3:         9
+## 4:       -26
+## 5:         1
+## 6:         0
+\end{verbatim}
+
+\hypertarget{graphics-in-galaaz}{%
+\section{Graphics in Galaaz}\label{graphics-in-galaaz}}
+
+Creating graphics in Galaaz is quite easy, as it can use all the power
+of ggplot2. There are many resources in the web that teaches ggplot, so
+here we give a quick example of ggplot integration with Ruby. We
+continue to use the :mtcars dataset and we will plot a diverging bar
+plot, showing cars that have `above' or `below' gas consuption. Let's
+first prepare the data frame with the necessary data:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# copy the R variable :mtcars to the Ruby mtcars variable}
+\NormalTok{mtcars = ~}\StringTok{:mtcars}
+
+\CommentTok{# create a new column 'car_name' to store the car names so that it can be}
+\CommentTok{# used for plotting. The 'rownames' of the data frame cannot be used as}
+\CommentTok{# data for plotting}
+\NormalTok{mtcars.car_name = R.rownames(}\StringTok{:mtcars}\NormalTok{)}
+
+\CommentTok{# compute normalized mpg and add it to a new column called mpg_z}
+\CommentTok{# Note that the mean value for mpg can be obtained by calling the 'mean'}
+\CommentTok{# function on the vector 'mtcars.mpg'.  The same with the standard}
+\CommentTok{# deviation 'sd'.  The vector is then rounded to two digits with 'round 2'}
+\NormalTok{mtcars.mpg_z = ((mtcars.mpg - mtcars.mpg.mean)/mtcars.mpg.sd).round }\DecValTok{2}
+
+\CommentTok{# create a new column 'mpg_type'. Function 'ifelse' is a vectorized function}
+\CommentTok{# that looks at every element of the mpg_z vector and if the value is below}
+\CommentTok{# 0, returns 'below', otherwise returns 'above'}
+\NormalTok{mtcars.mpg_type = (mtcars.mpg_z < }\DecValTok{0}\NormalTok{).ifelse(}\StringTok{"below"}\NormalTok{, }\StringTok{"above"}\NormalTok{)}
+
+\CommentTok{# order the mtcar data set by the mpg_z vector from smaler to larger values}
+\NormalTok{mtcars = mtcars[mtcars.mpg_z.order, }\StringTok{:all}\NormalTok{]}
+
+\CommentTok{# convert the car_name column to a factor to retain sorted order in plot}
+\NormalTok{mtcars.car_name = mtcars.car_name.factor }\StringTok{levels: }\NormalTok{mtcars.car_name}
+
+\CommentTok{# let's look at the final data frame}
+\NormalTok{puts mtcars.head}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##                      mpg cyl disp  hp drat    wt  qsec vs am gear carb
+## Cadillac Fleetwood  10.4   8  472 205 2.93 5.250 17.98  0  0    3    4
+## Lincoln Continental 10.4   8  460 215 3.00 5.424 17.82  0  0    3    4
+## Camaro Z28          13.3   8  350 245 3.73 3.840 15.41  0  0    3    4
+## Duster 360          14.3   8  360 245 3.21 3.570 15.84  0  0    3    4
+## Chrysler Imperial   14.7   8  440 230 3.23 5.345 17.42  0  0    3    4
+## Maserati Bora       15.0   8  301 335 3.54 3.570 14.60  0  1    5    8
+##                                car_name mpg_z mpg_type
+## Cadillac Fleetwood   Cadillac Fleetwood -1.61    below
+## Lincoln Continental Lincoln Continental -1.61    below
+## Camaro Z28                   Camaro Z28 -1.13    below
+## Duster 360                   Duster 360 -0.96    below
+## Chrysler Imperial     Chrysler Imperial -0.89    below
+## Maserati Bora             Maserati Bora -0.84    below
+\end{verbatim}
+
+Now, lets plot the diverging bar plot. When using gKnit, there is no
+need to call `R.awt' to create a plotting device, since gKnit does take
+care of it. Galaaz provides integration with ggplot. The interested
+reader should check online for more information on ggplot, since it is
+outside the scope of this manual describing how ggplot works. We give
+here but a brief description on how this plot is generated.
+
+ggplot implements the `grammar of graphics'. In this approach, plots are
+build by adding layers to the plot. On the first layer we describe what
+we want on the `x' and `y' axis of the plot. In this case, we have
+`car\_name' on the `x' axis and `mpg\_z' on the `y' axis. Then the type
+of graph is specified by adding `geom\_bar' (for a bar graph). We
+specify that our bars should be filled using `mpg\_type', which is
+either `above' or `bellow' giving then two colours for filling. On the
+next layer we specify the labels for the graph, then we add the title
+and subtitle. Finally, in a bar chart usually bars go on the vertical
+direction, but in this graph we want the bars to be horizontally layed
+so we add `coord\_flip'.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{require }\StringTok{'ggplot'}
+
+\NormalTok{puts mtcars.ggplot(E.aes(}\StringTok{x: :car_name}\NormalTok{, }\StringTok{y: :mpg_z}\NormalTok{, }\StringTok{label: :mpg_z}\NormalTok{)) +}
+\NormalTok{     R.geom_bar(E.aes(}\StringTok{fill: :mpg_type}\NormalTok{), }\StringTok{stat: 'identity'}\NormalTok{, }\StringTok{width: }\FloatTok{0.5}\NormalTok{) +}
+\NormalTok{     R.scale_fill_manual(}\StringTok{name: 'Mileage'}\NormalTok{,}
+                         \StringTok{labels: }\NormalTok{R.c(}\StringTok{'Above Average'}\NormalTok{, }\StringTok{'Below Average'}\NormalTok{),}
+                         \StringTok{values: }\NormalTok{R.c(}\StringTok{'above'}\NormalTok{: }\StringTok{'#00ba38'}\NormalTok{, }\StringTok{'below'}\NormalTok{: }\StringTok{'#f8766d'}\NormalTok{)) +}
+\NormalTok{     R.labs(}\StringTok{subtitle: "Normalised mileage from 'mtcars'"}\NormalTok{,}
+            \StringTok{title: "Diverging Bars"}\NormalTok{) + }
+\NormalTok{     R.coord_flip}
+\end{Highlighting}
+\end{Shaded}
+
+\includegraphics{/home/rbotafogo/desenv/galaaz/blogs/manual/manual_files/figure-latex/diverging_bar.pdf}
+
+\hypertarget{coding-with-tidyverse}{%
+\section{Coding with Tidyverse}\label{coding-with-tidyverse}}
+
+In R, and when coding with `tidyverse', arguments to a function are
+usually not \emph{referencially transparent}. That is, you can't replace
+a value with a seemingly equivalent object that you've defined
+elsewhere. To see the problem, let's first define a data frame:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df = R.data__frame(}\StringTok{x: }\NormalTok{(}\DecValTok{1}\NormalTok{..}\DecValTok{3}\NormalTok{), }\StringTok{y: }\NormalTok{(}\DecValTok{3}\NormalTok{..}\DecValTok{1}\NormalTok{))}
+\NormalTok{puts df}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+## 2 2 2
+## 3 3 1
+\end{verbatim}
+
+and now, let's look at this code:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my_var <-}\StringTok{ }\NormalTok{x}
+\KeywordTok{filter}\NormalTok{(df, my_var }\OperatorTok{==}\StringTok{ }\DecValTok{1}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+It generates the following error: "object `x' not found.
+
+However, in Galaaz, arguments are referencially transparent as can be
+seen by the code bellow. Note initally that `my\_var = :x' will not give
+the error ``object `x' not found'' since `:x' is treated as an
+expression and assigned to my\_var. Then when doing (my\_var.eq 1),
+my\_var is a variable that resolves to `:x' and it becomes equivalent to
+(:x.eq 1) which is what we want.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my_var = }\StringTok{:x}
+\NormalTok{puts df.filter(my_var.eq }\DecValTok{1}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+\end{verbatim}
+
+As stated by Hardley
+
+\begin{quote}
+dplyr code is ambiguous. Depending on what variables are defined where,
+filter(df, x == y) could be equivalent to any of:
+\end{quote}
+
+\begin{verbatim}
+df[df$x == df$y, ]
+df[df$x == y, ]
+df[x == df$y, ]
+df[x == y, ]
+\end{verbatim}
+
+In galaaz this ambiguity does not exist, filter(df, x.eq y) is not a
+valid expression as expressions are build with symbols. In doing
+filter(df, :x.eq y) we are looking for elements of the `x' column that
+are equal to a previously defined y variable. Finally in filter(df,
+:x.eq :y) we are looking for elements in which the `x' column value is
+equal to the `y' column value. This can be seen in the following two
+chunks of code:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{y = }\DecValTok{1}
+\NormalTok{x = }\DecValTok{2}
+
+\CommentTok{# looking for values where the 'x' column is equal to the 'y' column}
+\NormalTok{puts df.filter(}\StringTok{:x}\NormalTok{.eq }\StringTok{:y}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 2 2
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# looking for values where the 'x' column is equal to the 'y' variable}
+\CommentTok{# in this case, the number 1}
+\NormalTok{puts df.filter(}\StringTok{:x}\NormalTok{.eq y)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+\end{verbatim}
+
+\hypertarget{writing-a-function-that-applies-to-different-data-sets}{%
+\subsection{Writing a function that applies to different data
+sets}\label{writing-a-function-that-applies-to-different-data-sets}}
+
+Let's suppose that we want to write a function that receives as the
+first argument a data frame and as second argument an expression that
+adds a column to the data frame that is equal to the sum of elements in
+column `a' plus `x'.
+
+Here is the intended behaviour using the `mutate' function of `dplyr':
+
+\begin{verbatim}
+mutate(df1, y = a + x)
+mutate(df2, y = a + x)
+mutate(df3, y = a + x)
+mutate(df4, y = a + x)
+\end{verbatim}
+
+The naive approach to writing an R function to solve this problem is:
+
+\begin{verbatim}
+mutate_y <- function(df) {
+  mutate(df, y = a + x)
+}
+\end{verbatim}
+
+Unfortunately, in R, this function can fail silently if one of the
+variables isn't present in the data frame, but is present in the global
+environment. We will not go through here how to solve this problem in R.
+
+In Galaaz the method mutate\_y bellow will work fine and will never fail
+silently.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ mutate_y(df)}
+\NormalTok{  df.mutate(}\StringTok{:y}\NormalTok{.assign }\StringTok{:a}\NormalTok{ + }\StringTok{:x}\NormalTok{)}
+\KeywordTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+Here we create a data frame that has only one column named `x':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df1 = R.data__frame(}\StringTok{x: }\NormalTok{(}\DecValTok{1}\NormalTok{..}\DecValTok{3}\NormalTok{))}
+\NormalTok{puts df1}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x
+## 1 1
+## 2 2
+## 3 3
+\end{verbatim}
+
+Note that method mutate\_y will fail independetly from the fact that
+variable `a' is defined and in the scope of the method. Variable `a' has
+no relationship with the symbol `:a' used in the definition of
+`mutate\_y' above:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{a = }\DecValTok{10}
+\NormalTok{mutate_y(df1)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Message:
+##  Error in mutate_impl(.data, dots) :
+##   Evaluation error: object 'a' not found.
+## In addition: Warning message:
+## In mutate_impl(.data, dots) :
+##   mismatched protect/unprotect (unprotect with empty protect stack) (RError)
+## Translated to internal error
+\end{verbatim}
+
+\hypertarget{different-expressions}{%
+\subsection{Different expressions}\label{different-expressions}}
+
+Let's move to the next problem as presented by Hardley where trying to
+write a function in R that will receive two argumens, the first a
+variable and the second an expression is not trivial. Bellow we create a
+data frame and we want to write a function that groups data by a
+variable and summarises it by an expression:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{set.seed}\NormalTok{(}\DecValTok{123}\NormalTok{)}
+
+\NormalTok{df <-}\StringTok{ }\KeywordTok{data.frame}\NormalTok{(}
+  \DataTypeTok{g1 =} \KeywordTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{2}\NormalTok{),}
+  \DataTypeTok{g2 =} \KeywordTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{),}
+  \DataTypeTok{a =} \KeywordTok{sample}\NormalTok{(}\DecValTok{5}\NormalTok{),}
+  \DataTypeTok{b =} \KeywordTok{sample}\NormalTok{(}\DecValTok{5}\NormalTok{)}
+\NormalTok{)}
+
+\KeywordTok{as.data.frame}\NormalTok{(df) }
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 g2 a b
+## 1  1  1 2 1
+## 2  1  2 4 3
+## 3  2  1 5 4
+## 4  2  2 3 2
+## 5  2  1 1 5
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{d2 <-}\StringTok{ }\NormalTok{df }\OperatorTok{%>%}
+\StringTok{  }\KeywordTok{group_by}\NormalTok{(g1) }\OperatorTok{%>%}
+\StringTok{  }\KeywordTok{summarise}\NormalTok{(}\DataTypeTok{a =} \KeywordTok{mean}\NormalTok{(a))}
+           
+\KeywordTok{as.data.frame}\NormalTok{(d2)          }
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 a
+## 1  1 3
+## 2  2 3
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{d2 <-}\StringTok{ }\NormalTok{df }\OperatorTok{%>%}
+\StringTok{  }\KeywordTok{group_by}\NormalTok{(g2) }\OperatorTok{%>%}
+\StringTok{  }\KeywordTok{summarise}\NormalTok{(}\DataTypeTok{a =} \KeywordTok{mean}\NormalTok{(a))}
+           
+\KeywordTok{as.data.frame}\NormalTok{(d2)          }
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g2        a
+## 1  1 2.666667
+## 2  2 3.500000
+\end{verbatim}
+
+As shown by Hardley, one might expect this function to do the trick:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my_summarise <-}\StringTok{ }\ControlFlowTok{function}\NormalTok{(df, group_var) \{}
+\NormalTok{  df }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{group_by}\NormalTok{(group_var) }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{summarise}\NormalTok{(}\DataTypeTok{a =} \KeywordTok{mean}\NormalTok{(a))}
+\NormalTok{\}}
+
+\CommentTok{# my_summarise(df, g1)}
+\CommentTok{#> Error: Column `group_var` is unknown}
+\end{Highlighting}
+\end{Shaded}
+
+In order to solve this problem, coding with dplyr requires the
+introduction of many new concepts and functions such as `quo', `quos',
+`enquo', `enquos', `!!' (bang bang), `!!!' (triple bang). Again, we'll
+leave to Hardley the explanation on how to use all those functions.
+
+Now, let's try to implement the same function in galaaz. The next code
+block first prints the `df' data frame defined previously in R (to
+access an R variable from Galaaz, we use the tilda operator
+`\textasciitilde{}' applied to the R variable name as symbol, i.e.,
+`:df'.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts ~}\StringTok{:df}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 g2 a b
+## 1  1  1 2 1
+## 2  1  2 4 3
+## 3  2  1 5 4
+## 4  2  2 3 2
+## 5  2  1 1 5
+\end{verbatim}
+
+We then create the `my\_summarize' method and call it passing the R data
+frame and the group by variable `:g1':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ my_summarize(df, group_var)}
+\NormalTok{  df.group_by(group_var).}
+\NormalTok{    summarize(}\StringTok{a: :a}\NormalTok{.mean)}
+\KeywordTok{end}
+
+\NormalTok{puts my_summarize(}\StringTok{:df}\NormalTok{, }\StringTok{:g1}\NormalTok{).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 a
+## 1  1 3
+## 2  2 3
+\end{verbatim}
+
+It works!!! Well, let's make sure this was not just some coincidence
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts my_summarize(}\StringTok{:df}\NormalTok{, }\StringTok{:g2}\NormalTok{).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g2        a
+## 1  1 2.666667
+## 2  2 3.500000
+\end{verbatim}
+
+Great, everything is fine! No magic, no new functions, no complexities,
+just normal, standard Ruby code. If you've ever done NSE in R, this
+certainly feels much safer and easy to implement.
+
+\hypertarget{different-input-variables}{%
+\subsection{Different input variables}\label{different-input-variables}}
+
+In the previous section we've managed to get rid of all NSE formulation
+for a simple example, but does this remain true for more complex
+examples, or will the Galaaz way prove inpractical for more complex
+code?
+
+In the next example Hardley proposes us to write a function that given
+an expression such as `a' or `a * b', calculates three summaries. What
+we want a function that does the same as these R statements:
+
+\begin{verbatim}
+summarise(df, mean = mean(a), sum = sum(a), n = n())
+#> # A tibble: 1 x 3
+#>    mean   sum     n
+#>   <dbl> <int> <int>
+#> 1     3    15     5
+
+summarise(df, mean = mean(a * b), sum = sum(a * b), n = n())
+#> # A tibble: 1 x 3
+#>    mean   sum     n
+#>   <dbl> <int> <int>
+#> 1   9    45     5
+\end{verbatim}
+
+Let's try it in galaaz:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ my_summarise2(df, expr)}
+\NormalTok{  df.summarize(}
+    \StringTok{mean: }\NormalTok{E.mean(expr),}
+    \StringTok{sum: }\NormalTok{E.sum(expr),}
+    \StringTok{n: }\NormalTok{E.n}
+\NormalTok{  )}
+\KeywordTok{end}
+
+\NormalTok{puts my_summarise2((~}\StringTok{:df}\NormalTok{), }\StringTok{:a}\NormalTok{)}
+\NormalTok{puts }\StringTok{"\textbackslash{}n"}
+\NormalTok{puts my_summarise2((~}\StringTok{:df}\NormalTok{), }\StringTok{:a}\NormalTok{ * }\StringTok{:b}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   mean sum n
+## 1    3  15 5
+## 
+##   mean sum n
+## 1    9  45 5
+\end{verbatim}
+
+Once again, there is no need to use any special theory or functions. The
+only point to be careful about is the use of `E' to build expressions
+from functions `mean', `sum' and `n'.
+
+\hypertarget{different-input-and-output-variable}{%
+\subsection{Different input and output
+variable}\label{different-input-and-output-variable}}
+
+Now the next challenge presented by Hardley is to vary the name of the
+output variables based on the received expression. So, if the input
+expression is `a', we want our data frame columns to be named `mean\_a'
+and `sum\_a'. Now, if the input expression is `b', columns should be
+named `mean\_b' and `sum\_b'.
+
+\begin{verbatim}
+mutate(df, mean_a = mean(a), sum_a = sum(a))
+#> # A tibble: 5 x 6
+#>      g1    g2     a     b mean_a sum_a
+#>   <dbl> <dbl> <int> <int>  <dbl> <int>
+#> 1     1     1     1     3      3    15
+#> 2     1     2     4     2      3    15
+#> 3     2     1     2     1      3    15
+#> 4     2     2     5     4      3    15
+#> # … with 1 more row
+
+mutate(df, mean_b = mean(b), sum_b = sum(b))
+#> # A tibble: 5 x 6
+#>      g1    g2     a     b mean_b sum_b
+#>   <dbl> <dbl> <int> <int>  <dbl> <int>
+#> 1     1     1     1     3      3    15
+#> 2     1     2     4     2      3    15
+#> 3     2     1     2     1      3    15
+#> 4     2     2     5     4      3    15
+#> # … with 1 more row
+\end{verbatim}
+
+In order to solve this problem in R, Hardley needs to introduce some
+more new functions and notations: `quo\_name' and the `:=' operator from
+package `rlang'
+
+Here is our Ruby code:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ my_mutate(df, expr)}
+\NormalTok{  mean_name = }\StringTok{"mean_}\OtherTok{#\{}\NormalTok{expr.to_s}\OtherTok{\}}\StringTok{"}
+\NormalTok{  sum_name = }\StringTok{"sum_}\OtherTok{#\{}\NormalTok{expr.to_s}\OtherTok{\}}\StringTok{"}
+
+\NormalTok{  df.mutate(mean_name => E.mean(expr),}
+\NormalTok{            sum_name => E.sum(expr))}
+\KeywordTok{end}
+
+\NormalTok{puts my_mutate((~}\StringTok{:df}\NormalTok{), }\StringTok{:a}\NormalTok{)}
+\NormalTok{puts }\StringTok{"\textbackslash{}n"}
+\NormalTok{puts my_mutate((~}\StringTok{:df}\NormalTok{), }\StringTok{:b}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 g2 a b mean_a sum_a
+## 1  1  1 2 1      3    15
+## 2  1  2 4 3      3    15
+## 3  2  1 5 4      3    15
+## 4  2  2 3 2      3    15
+## 5  2  1 1 5      3    15
+## 
+##   g1 g2 a b mean_b sum_b
+## 1  1  1 2 1      3    15
+## 2  1  2 4 3      3    15
+## 3  2  1 5 4      3    15
+## 4  2  2 3 2      3    15
+## 5  2  1 1 5      3    15
+\end{verbatim}
+
+It really seems that ``Non Standard Evaluation'' is actually quite
+standard in Galaaz! But, you might have noticed a small change in the
+way the arguments to the mutate method were called. In a previous
+example we used df.summarise(mean: E.mean(:a), \ldots{}) where the
+column name was followed by a `:' colom. In this example, we have
+df.mutate(mean\_name =\textgreater{} E.mean(expr), \ldots{}) and
+variable mean\_name is not followed by `:' but by `=\textgreater{}'.
+This is standard Ruby notation.
+
+{[}explain\ldots{}.{]}
+
+\hypertarget{capturing-multiple-variables}{%
+\subsection{Capturing multiple
+variables}\label{capturing-multiple-variables}}
+
+Moving on with new complexities, Hardley proposes us to solve the
+problem in which the summarise function will receive any number of
+grouping variables.
+
+This again is quite standard Ruby. In order to receive an undefined
+number of paramenters the paramenter is preceded by '*':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ my_summarise3(df, *group_vars)}
+\NormalTok{  df.group_by(*group_vars).}
+\NormalTok{    summarise(}\StringTok{a: }\NormalTok{E.mean(}\StringTok{:a}\NormalTok{))}
+\KeywordTok{end}
+
+\NormalTok{puts my_summarise3((~}\StringTok{:df}\NormalTok{), }\StringTok{:g1}\NormalTok{, }\StringTok{:g2}\NormalTok{).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 g2 a
+## 1  1  1 2
+## 2  1  2 4
+## 3  2  1 3
+## 4  2  2 3
+\end{verbatim}
+
+\hypertarget{why-does-r-require-nse-and-galaaz-does-not}{%
+\subsection{Why does R require NSE and Galaaz does
+not?}\label{why-does-r-require-nse-and-galaaz-does-not}}
+
+NSE introduces a number of new concepts, such as `quoting',
+`quasiquotation', `unquoting' and `unquote-splicing', while in Galaaz
+none of those concepts are needed. What gives?
+
+R is an extremely flexible language and it has lazy evaluation of
+parameters. When in R a function is called as `summarise(df, a = b)',
+the summarise function receives the litteral `a = b' parameter and can
+work with this as if it were a string. In R, it is not clear what a and
+b are, they can be expressions or they can be variables, it is up to the
+function to decide what `a = b' means.
+
+In Ruby, there is no lazy evaluation of parameters and `a' is always a
+variable and so is `b'. Variables assume their value as soon as they are
+used, so `x = a' is immediately evaluate and variable `x' will receive
+the value of variable `a' as soon as the Ruby statement is executed.
+Ruby also provides the notion of a symbol; `:a' is a symbol and does not
+evaluate to anything. Galaaz uses Ruby symbols to build expressions that
+are not bound to anything: `:a.eq :b' is clearly an expression and has
+no relationship whatsoever with the statment `a = b'. By using symbols,
+variables and expressions all the possible ambiguities that are found in
+R are eliminated in Galaaz.
+
+The main problem that remains, is that in R, functions are not clearly
+documented as what type of input they are expecting, they might be
+expecting regular variables or they might be expecting expressions and
+the R function will know how to deal with an input of the form `a = b',
+now for the Ruby developer it might not be immediately clear if it
+should call the function passing the value `true' if variable `a' is
+equal to variable `b' or if it should call the function passing the
+expression `:a.eq :b'.
+
+\hypertarget{advanced-dplyr-features}{%
+\subsection{Advanced dplyr features}\label{advanced-dplyr-features}}
+
+In the blog: Programming with dplyr by using dplyr
+(\url{https://www.r-bloggers.com/programming-with-dplyr-by-using-dplyr/})
+Iñaki Úcar shows surprise that some R users are trying to code in dplyr
+avoiding the use of NSE. For instance he says:
+
+\begin{quote}
+Take the example of seplyr. It stands for standard evaluation dplyr, and
+enables us to program over dplyr without having ``to bring in (or study)
+any deep-theory or heavy-weight tools such as rlang/tidyeval''.
+\end{quote}
+
+For me, there isn't really any surprise that users are trying to avoid
+dplyr deep-theory. R users frequently are not programmers and learning
+to code is already hard business, on top of that, having to learn how to
+`quote' or `enquo' or `quos' or `enquos' is not necessarily a `piece of
+cake'. So much so, that `tidyeval' has some more advanced functions that
+instead of using quoted expressions, uses strings as arguments.
+
+In the following examples, we show the use of functions `group\_by\_at',
+`summarise\_at' and `rename\_at' that receive strings as argument. The
+data frame used in `starwars' that describes features of characters in
+the Starwars movies:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts (~}\StringTok{:starwars}\NormalTok{).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##             name height mass  hair_color  skin_color eye_color birth_year
+## 1 Luke Skywalker    172   77       blond        fair      blue       19.0
+## 2          C-3PO    167   75        <NA>        gold    yellow      112.0
+## 3          R2-D2     96   32        <NA> white, blue       red       33.0
+## 4    Darth Vader    202  136        none       white    yellow       41.9
+## 5    Leia Organa    150   49       brown       light     brown       19.0
+## 6      Owen Lars    178  120 brown, grey       light      blue       52.0
+##   gender homeworld species
+## 1   male  Tatooine   Human
+## 2   <NA>  Tatooine   Droid
+## 3   <NA>     Naboo   Droid
+## 4   male  Tatooine   Human
+## 5 female  Alderaan   Human
+## 6   male  Tatooine   Human
+##                                                                                                                                       films
+## 1                                           Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope, The Force Awakens
+## 2                    Attack of the Clones, The Phantom Menace, Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope
+## 3 Attack of the Clones, The Phantom Menace, Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope, The Force Awakens
+## 4                                                              Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope
+## 5                                           Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope, The Force Awakens
+## 6                                                                                     Attack of the Clones, Revenge of the Sith, A New Hope
+##                             vehicles                starships
+## 1 Snowspeeder, Imperial Speeder Bike X-wing, Imperial shuttle
+## 2                                                            
+## 3                                                            
+## 4                                             TIE Advanced x1
+## 5              Imperial Speeder Bike                         
+## 6
+\end{verbatim}
+
+The grouped\_mean function bellow will receive a grouping variable and
+calculate summaries for the value\_variables given:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{grouped_mean <-}\StringTok{ }\ControlFlowTok{function}\NormalTok{(data, grouping_variables, value_variables) \{}
+\NormalTok{  data }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{group_by_at}\NormalTok{(grouping_variables) }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{mutate}\NormalTok{(}\DataTypeTok{count =} \KeywordTok{n}\NormalTok{()) }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{summarise_at}\NormalTok{(}\KeywordTok{c}\NormalTok{(value_variables, }\StringTok{"count"}\NormalTok{), mean, }\DataTypeTok{na.rm =} \OtherTok{TRUE}\NormalTok{) }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{rename_at}\NormalTok{(value_variables, }\KeywordTok{funs}\NormalTok{(}\KeywordTok{paste0}\NormalTok{(}\StringTok{"mean_"}\NormalTok{, .)))}
+\NormalTok{    \}}
+
+\NormalTok{gm =}\StringTok{ }\NormalTok{starwars }\OperatorTok{%>%}\StringTok{ }
+\StringTok{   }\KeywordTok{grouped_mean}\NormalTok{(}\StringTok{"eye_color"}\NormalTok{, }\KeywordTok{c}\NormalTok{(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth_year"}\NormalTok{))}
+
+\KeywordTok{as.data.frame}\NormalTok{(gm)   }
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##        eye_color mean_mass mean_birth_year count
+## 1          black  76.28571        33.00000    10
+## 2           blue  86.51667        67.06923    19
+## 3      blue-gray  77.00000        57.00000     1
+## 4          brown  66.09231       108.96429    21
+## 5           dark       NaN             NaN     1
+## 6           gold       NaN             NaN     1
+## 7  green, yellow 159.00000             NaN     1
+## 8          hazel  66.00000        34.50000     3
+## 9         orange 282.33333       231.00000     8
+## 10          pink       NaN             NaN     1
+## 11           red  81.40000        33.66667     5
+## 12     red, blue       NaN             NaN     1
+## 13       unknown  31.50000             NaN     3
+## 14         white  48.00000             NaN     1
+## 15        yellow  81.11111        76.38000    11
+\end{verbatim}
+
+The same code with Galaaz, becomes:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ grouped_mean(data, grouping_variables, value_variables)}
+\NormalTok{  data.}
+\NormalTok{    group_by_at(grouping_variables).}
+\NormalTok{    mutate(}\StringTok{count: }\NormalTok{E.n).}
+\NormalTok{    summarise_at(E.c(value_variables, }\StringTok{"count"}\NormalTok{), ~}\StringTok{:mean}\NormalTok{, }\StringTok{na__rm: }\DecValTok{true}\NormalTok{).}
+\NormalTok{    rename_at(value_variables, E.funs(E.paste0(}\StringTok{"mean_"}\NormalTok{, value_variables)))}
+\KeywordTok{end}
+
+\NormalTok{puts grouped_mean((~}\StringTok{:starwars}\NormalTok{), }\StringTok{"eye_color"}\NormalTok{, E.c(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth_year"}\NormalTok{)).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##        eye_color mean_mass mean_birth_year count
+## 1          black  76.28571        33.00000    10
+## 2           blue  86.51667        67.06923    19
+## 3      blue-gray  77.00000        57.00000     1
+## 4          brown  66.09231       108.96429    21
+## 5           dark       NaN             NaN     1
+## 6           gold       NaN             NaN     1
+## 7  green, yellow 159.00000             NaN     1
+## 8          hazel  66.00000        34.50000     3
+## 9         orange 282.33333       231.00000     8
+## 10          pink       NaN             NaN     1
+## 11           red  81.40000        33.66667     5
+## 12     red, blue       NaN             NaN     1
+## 13       unknown  31.50000             NaN     3
+## 14         white  48.00000             NaN     1
+## 15        yellow  81.11111        76.38000    11
+\end{verbatim}
+
+{[}TO BE CONTINUED\ldots{}{]}
+
+\hypertarget{contributing}{%
+\section{Contributing}\label{contributing}}
+
+\begin{itemize}
+\tightlist
+\item
+  Fork it
+\item
+  Create your feature branch (git checkout -b my-new-feature)
+\item
+  Write Tests!
+\item
+  Commit your changes (git commit -am `Add some feature')
+\item
+  Push to the branch (git push origin my-new-feature)
+\item
+  Create new Pull Request
+\end{itemize}
+
+
+\end{document}