galaaz 2.1.7 → 2.1.8

data/blogs/oh_my/oh_my.tex

@@ -165,6 +165,28 @@
 % Command to import an R variable to latex
 \newcommand{\RtoLatex}[2]{\newcommand{#1}{#2}}
 
+% Soft-wrap Pandoc highlighted code/output boxes (Shaded + Highlighting).
+% This runs after Pandoc's default \DefineVerbatimEnvironment{Highlighting}
+% (header includes come later in the generated .tex). Prefer manual line
+% breaks in Rmd sources; breaklines is a safety net for leftovers/output.
+% Requires TinyTeX/TeX Live package: tlmgr install fvextra
+\IfFileExists{fvextra.sty}{%
+  \usepackage{fvextra}%
+  \DefineVerbatimEnvironment{Highlighting}{Verbatim}{%
+    breaklines=true,
+    breakanywhere=true,
+    breakindent=1.5em,
+    fontsize=\small,
+    commandchars=\\\{\}%
+  }%
+}{%
+  % fancyvrb is already loaded by Pandoc; shrink code so more fits per line.
+  \DefineVerbatimEnvironment{Highlighting}{Verbatim}{%
+    fontsize=\small,
+    commandchars=\\\{\}%
+  }%
+}
+
 % 
 %\newcommand{\atraso}[1]{\color{red} \textbf {Tempo desde a Assinatura do Contrato: #1 dias}}
 \usepackage{bookmark}
@@ -189,8 +211,8 @@
 }
 \section{Introduction}\label{introduction}
 
-This paper introduces and compares Galaaz with R's S4. It is a shameless
-rip off of
+This paper introduces and compares Galaaz with R's S4. It is
+\textbf{modeled closely} on
 \href{https://cran.r-project.org/doc/contrib/Genolini-S4tutorialV0-5en.pdf}{``A
 `(not so)' Short Introduction to S4''} by Christophe Genolini and
 follows the same structure and examples presented there.
@@ -202,13 +224,13 @@ between RinRuby or similar solutions in Python, such as
 \href{https://pypi.python.org/pypi/PypeR/1.1.0}{PypeR},
 \href{http://rpy2.bitbucket.org/}{rpy2} and other similar solutions.
 
-\textbf{Galaaz 2.0} runs on
-\textbf{\href{https://www.jruby.org/}{JRuby}} and drives \textbf{GNU R}
-through a \textbf{bridge}, so Ruby code can create and manipulate R
-objects and call R functions while staying idiomatic Ruby. An earlier
-prototype used Oracle's \textbf{GraalVM} with \textbf{TruffleRuby} and
-\textbf{FastR}; that stack is historical and is \textbf{not} what
-current Galaaz targets.
+\textbf{Galaaz 2.0} supports
+\textbf{\href{https://www.jruby.org/}{JRuby}} or \textbf{CRuby} equally
+and drives \textbf{GNU R} through a \textbf{bridge}, so Ruby code can
+create and manipulate R objects and call R functions while staying
+idiomatic Ruby. An earlier prototype used Oracle's \textbf{GraalVM} with
+\textbf{TruffleRuby} and \textbf{FastR}; that stack is historical and is
+\textbf{not} what current Galaaz targets.
 
 \section{Bases of Object Programming}\label{bases-of-object-programming}
 
@@ -244,7 +266,7 @@ also not a ``compile'' time type, since R is not compiled. The type is
 checked at runtime. The same checking can be done in Ruby and we will do
 it later in this document.
 
-In the example bellow, we create class Trajectories with two instance
+In the example below, we create class Trajectories with two instance
 variables, `times' and `matrix'. We will not go over the details of
 instance variables in Ruby, but here we created those variables with the
 keyword `attr\_reader' and a colom before the variables name:
@@ -259,8 +281,8 @@ keyword `attr\_reader' and a colom before the variables name:
 \end{Shaded}
 
 In order to create a new instance of object Trajectories we call method
-new on the class and we can store the result in a varible (not an
-instance variable) as bellow:
+new on the class and we can store the result in a variable (not an
+instance variable) as below:
 
 \begin{Shaded}
 \begin{Highlighting}[]
@@ -279,7 +301,7 @@ contents as in R.
 \end{Shaded}
 
 \begin{verbatim}
-## #<RC::Trajectories:0x378c2595>
+## #<RC::Trajectories:0x4433c45f>
 \end{verbatim}
 
 To see the contents of an object, one needs to access its components
@@ -297,7 +319,7 @@ Since there is no content stored in `times' nor `matrix', nil is
 returned. In order to add a value in the variables, we need to add a
 constructor to the class Trajectories. In R, a constructor is build by
 default, in Ruby, this has to be created by adding a method called
-`initialize'. In the example bellow, we will create the initializer that
+`initialize'. In the example below, we will create the initializer that
 accepts two values, a `times' value and a `matrix' value and they are
 used to initialize the value of the instance variables:
 
@@ -336,7 +358,7 @@ Since Galaaz is Ruby and not R, some syntax adjustments are sometimes
 necessary. For instance, in R, a range is represented as `(1:4)', in
 Ruby, the same range is represented as `(1..4)'. When passing arguments
 to an R function in R one uses the `=' sign after the slot name; in R,
-one uses the `:' operator after parameter's name as we can see bellow:
+one uses the `:' operator after parameter's name as we can see below:
 
 \begin{Shaded}
 \begin{Highlighting}[]
@@ -344,7 +366,8 @@ one uses the `:' operator after parameter's name as we can see bellow:
 \OtherTok{@traj} \OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{))}
 
 \CommentTok{\# Create a Trajectories with times and matrix}
-\OtherTok{@traj2} \OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{), }\WarningTok{matrix:} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{4}\NormalTok{), }\WarningTok{ncol:} \DecValTok{2}\NormalTok{))}
+\OtherTok{@traj2} \OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{), }\WarningTok{matrix:} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{4}\NormalTok{),}
+  \WarningTok{ncol:} \DecValTok{2}\NormalTok{))}
 \end{Highlighting}
 \end{Shaded}
 
@@ -411,7 +434,8 @@ R and the corresponding Galaaz:
 +     times=c(1: 10, (6: 16) *2),
 +     traj=rbind(
 +         matrix (seq (16,19, length=21), ncol=21, nrow=50, byrow=TRUE),
-+         matrix (seq (15.8, 18, length=21), ncol=21, nrow=30, byrow=TRUE)
++         matrix (seq (15.8, 18, length=21), ncol=21, nrow=30,
+  byrow=TRUE)
 +     )+rnorm (21*80,0,0.2)
 + )
 \end{verbatim}
@@ -430,12 +454,16 @@ This same code in Galaaz becomes:
                                \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{15.7}\NormalTok{, }\FloatTok{15.6}\NormalTok{, }\FloatTok{15.8}\NormalTok{, }\DecValTok{16}\NormalTok{)))}
 
 \OtherTok{@trajStAnne} \OperatorTok{=}
-  \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{10}\NormalTok{), }\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{6}\OperatorTok{..}\DecValTok{16}\NormalTok{) }\OperatorTok{*} \DecValTok{2}\NormalTok{),}
-                   \WarningTok{matrix:}\NormalTok{ (}\ConstantTok{R}\AttributeTok{.rbind}\NormalTok{(}
-                             \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{(}\ConstantTok{R}\AttributeTok{.seq}\NormalTok{(}\DecValTok{16}\NormalTok{, }\DecValTok{19}\NormalTok{, }\WarningTok{length:} \DecValTok{21}\NormalTok{), }\WarningTok{ncol:} \DecValTok{21}\NormalTok{,}
-                                      \WarningTok{nrow:} \DecValTok{50}\NormalTok{, }\WarningTok{byrow:} \DecValTok{true}\NormalTok{),}
-                             \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{(}\ConstantTok{R}\AttributeTok{.seq}\NormalTok{(}\FloatTok{15.8}\NormalTok{, }\DecValTok{18}\NormalTok{, }\WarningTok{length:} \DecValTok{21}\NormalTok{), }\WarningTok{ncol:} \DecValTok{21}\NormalTok{,}
-                                      \WarningTok{nrow:} \DecValTok{30}\NormalTok{, }\WarningTok{byrow:} \DecValTok{true}\NormalTok{)) }\OperatorTok{+} \ConstantTok{R}\AttributeTok{.rnorm}\NormalTok{(}\DecValTok{21}\OperatorTok{*}\DecValTok{80}\NormalTok{, }\DecValTok{0}\NormalTok{, }\FloatTok{0.2}\NormalTok{)))}
+  \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}
+    \WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{10}\NormalTok{), }\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{6}\OperatorTok{..}\DecValTok{16}\NormalTok{) }\OperatorTok{*} \DecValTok{2}\NormalTok{),}
+    \WarningTok{matrix:}\NormalTok{ (}
+      \ConstantTok{R}\AttributeTok{.rbind}\NormalTok{(}
+        \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{(}\ConstantTok{R}\AttributeTok{.seq}\NormalTok{(}\DecValTok{16}\NormalTok{, }\DecValTok{19}\NormalTok{, }\WarningTok{length:} \DecValTok{21}\NormalTok{),}
+                 \WarningTok{ncol:} \DecValTok{21}\NormalTok{, }\WarningTok{nrow:} \DecValTok{50}\NormalTok{, }\WarningTok{byrow:} \DecValTok{true}\NormalTok{),}
+        \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{(}\ConstantTok{R}\AttributeTok{.seq}\NormalTok{(}\FloatTok{15.8}\NormalTok{, }\DecValTok{18}\NormalTok{, }\WarningTok{length:} \DecValTok{21}\NormalTok{),}
+                 \WarningTok{ncol:} \DecValTok{21}\NormalTok{, }\WarningTok{nrow:} \DecValTok{30}\NormalTok{, }\WarningTok{byrow:} \DecValTok{true}\NormalTok{)}
+\NormalTok{      ) }\OperatorTok{+} \ConstantTok{R}\AttributeTok{.rnorm}\NormalTok{(}\DecValTok{21} \OperatorTok{*} \DecValTok{80}\NormalTok{, }\DecValTok{0}\NormalTok{, }\FloatTok{0.2}\NormalTok{)}
+\NormalTok{    ))}
 \end{Highlighting}
 \end{Shaded}
 
@@ -456,10 +484,10 @@ correctly set:
 ## [1] 1 3 4 5
 ## 
 ##          [,1] [,2] [,3] [,4]
-## g2_v2114 15.0 15.1 15.2 15.2
-## g2_v2115 16.0 15.9 16.0 16.4
-## g2_v2116 15.2   NA 15.3 15.3
-## g2_v2117 15.7 15.6 15.8 16.0
+## g2_v7095 15.0 15.1 15.2 15.2
+## g2_v7096 16.0 15.9 16.0 16.4
+## g2_v7097 15.2   NA 15.3 15.3
+## g2_v7098 15.7 15.6 15.8 16.0
 ## 
 ##  [1]  1  2  3  4  5  6  7  8  9 10 12 14 16 18 20 22 24 26 28 30 32
 \end{verbatim}
@@ -477,7 +505,7 @@ default values in this document, with the default being `nil'. This was
 necessary in order to be able to create our constructor and passing it
 the proper values.
 
-In the example bellow, a class TrajectoriesBis is created with default
+In the example below, a class TrajectoriesBis is created with default
 value 1 for times and a matrix with no elements in matrix.
 
 \begin{Shaded}
@@ -596,7 +624,7 @@ method `plot' is added to Trajectories. At this point, Renjin and Galaaz
 do not yet have plotting capabilities, so we will have to skip this
 method and go directly to the implementation of the `print' method.
 
-Bellow is the R code for method print:
+Below is the R code for method print:
 
 \begin{verbatim}
 > setMethod ("print","Trajectories",
@@ -673,10 +701,10 @@ Trajectories's print we need to write `Kernel.print'.
 ## 5
 ## traj =
 ##          [,1] [,2] [,3] [,4]
-## g2_v2114 15.0 15.1 15.2 15.2
-## g2_v2115 16.0 15.9 16.0 16.4
-## g2_v2116 15.2   NA 15.3 15.3
-## g2_v2117 15.7 15.6 15.8 16.0
+## g2_v7095 15.0 15.1 15.2 15.2
+## g2_v7096 16.0 15.9 16.0 16.4
+## g2_v7097 15.2   NA 15.3 15.3
+## g2_v7098 15.7 15.6 15.8 16.0
 ## ******* End Print (trajectories) *******
 \end{verbatim}
 
@@ -718,15 +746,17 @@ we have already seen, others will be described now:
   look like a method of the object. For instance, R.nrow(@matrix), can
   be called by doing @matrix.nrow;
 \item
-  In R, every number is converted to a vector and this can be done with
-  method R.i. Converting a vector with only one number back to a number
-  can be done with method `.gz'. So if @num is an R vector that holds a
-  number, then @num.gz is a number that can be used normally with Ruby
-  methods;
+  In R, every number is a length-1 vector. In Galaaz 2.0, unwrap a
+  length-1 R vector to a Ruby number with
+  \texttt{\textgreater{}\textgreater{}\ 0} (or
+  \texttt{unboxed\_get(0)}). Older Galaaz docs used \texttt{.gz} /
+  \texttt{\textless{}\textless{}\ 0} for the same idea;
+  \texttt{\textless{}\textless{}} still works as a compatibility alias
+  for \texttt{\textgreater{}\textgreater{}};
 \item
   R functions and Ruby methods can be used freely in Galaaz. We show
-  bellow two different ways of getting the minimum of a number, either
-  by calling R.min or by getting the minimum of an array, with the min
+  below two different ways of getting the minimum of a number, either by
+  calling R.min or by getting the minimum of an array, with the min
   method;
 \item
   Galaaz allows for method `chaining'. Method chaining, also known as
@@ -734,16 +764,16 @@ we have already seen, others will be described now:
   calls in object-oriented programming languages. Each method returns an
   object, allowing the calls to be chained together in a single
   statement without requiring variables to store the intermediate
-  results. For instance @matrix.nrow.gz, which returns the number of
-  rows of the matrix as a number;
+  results. For instance
+  \texttt{@matrix.nrow\ \textgreater{}\textgreater{}\ 0}, which returns
+  the number of rows of the matrix as a Ruby number;
 \item
   Ranges in Ruby are represented by (x..y), where x is the beginning of
   the range and y its end. An R matrix can be indexed by range,
   \href{mailto:object@traj}{\nolinkurl{object@traj}}{[}1:nrowShow,1:ncolShow{]},
   the same result is obtained in Galaaz by indexing @matrix
   {[}(1..nrow\_show), (1..ncol\_show){]}. Observe that this statement is
-  then chained with the format function and with the pp method to print
-  the matrix.
+  then chained with the format function and printed with \texttt{puts}.
 \end{itemize}
 
 \begin{Shaded}
@@ -758,10 +788,11 @@ we have already seen, others will be described now:
     \FunctionTok{puts}\NormalTok{(}\StringTok{"*** Class Trajectories, method Show *** "}\NormalTok{)}
     \DataTypeTok{Kernel}\AttributeTok{.print}\NormalTok{(}\StringTok{"times = "}\NormalTok{)}
     \FunctionTok{puts} \OtherTok{@times}
-\NormalTok{    nrow\_show }\OperatorTok{=} \KeywordTok{[}\DecValTok{10}\NormalTok{, }\OtherTok{@matrix}\AttributeTok{.nrow} \OperatorTok{\textless{}\textless{}} \DecValTok{0}\KeywordTok{]}\AttributeTok{.min}
-\NormalTok{    ncol\_show }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.min}\NormalTok{(}\DecValTok{10}\NormalTok{, }\OtherTok{@matrix}\AttributeTok{.ncol}\NormalTok{) }\OperatorTok{\textless{}\textless{}} \DecValTok{0}
+\NormalTok{    nrow\_show }\OperatorTok{=} \KeywordTok{[}\DecValTok{10}\NormalTok{, }\OtherTok{@matrix}\AttributeTok{.nrow} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\KeywordTok{]}\AttributeTok{.min}
+\NormalTok{    ncol\_show }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.min}\NormalTok{(}\DecValTok{10}\NormalTok{, }\OtherTok{@matrix}\AttributeTok{.ncol}\NormalTok{) }\OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}
     \FunctionTok{puts}\NormalTok{(}\StringTok{"* Traj (limited to a matrix 10x10) = "}\NormalTok{)}
-    \FunctionTok{puts} \OtherTok{@matrix}\KeywordTok{[}\NormalTok{(}\DecValTok{1}\OperatorTok{..}\NormalTok{nrow\_show), (}\DecValTok{1}\OperatorTok{..}\NormalTok{ncol\_show)}\KeywordTok{]}\AttributeTok{.format}\NormalTok{(}\WarningTok{digits:} \DecValTok{2}\NormalTok{, }\WarningTok{nsmall:} \DecValTok{2}\NormalTok{)}
+    \FunctionTok{puts} \OtherTok{@matrix}\KeywordTok{[}\NormalTok{(}\DecValTok{1}\OperatorTok{..}\NormalTok{nrow\_show), (}\DecValTok{1}\OperatorTok{..}\NormalTok{ncol\_show)}\KeywordTok{]}\AttributeTok{.format}\NormalTok{(}\WarningTok{digits:} \DecValTok{2}\NormalTok{,}
+      \WarningTok{nsmall:} \DecValTok{2}\NormalTok{)}
     \FunctionTok{puts}\NormalTok{(}\StringTok{"******* End Show (trajectories) ******* "}\NormalTok{)}
   \ControlFlowTok{end}
   
@@ -776,26 +807,52 @@ we have already seen, others will be described now:
 \end{Shaded}
 
 \begin{verbatim}
-## parse error
-\end{verbatim}
-
-\begin{verbatim}
-## /home/rbotafogo/desenv_linux/galaaz/lib/new_bridge/session_client.rb:268:in 'eval_r'
-## /home/rbotafogo/desenv_linux/galaaz/lib/R_interface/new_bridge_adapter.rb:231:in 'eval_r_with_result'
-## /home/rbotafogo/desenv_linux/galaaz/lib/R_interface/rsupport.rb:359:in 'exec_function'
-## /home/rbotafogo/desenv_linux/galaaz/lib/R_interface/rsupport.rb:618:in 'process_missing_dispatch'
-## /home/rbotafogo/desenv_linux/galaaz/lib/R_interface/rsupport.rb:468:in 'process_missing'
-## /home/rbotafogo/desenv_linux/galaaz/lib/R_interface/robject.rb:404:in 'method_missing'
-## /home/rbotafogo/desenv_linux/galaaz/lib/util/exec_ruby.rb:180:in 'show'
-## /home/rbotafogo/desenv_linux/galaaz/lib/util/exec_ruby.rb:170:in 'exec_ruby'
-## org/jruby/RubyKernel.java:1268:in 'eval'
-## /home/rbotafogo/desenv_linux/galaaz/lib/util/exec_ruby.rb:169:in 'exec_ruby'
-## /home/rbotafogo/desenv_linux/galaaz/lib/gknit/knitr_engine.rb:777:in 'block in initialize'
-## org/jruby/RubyBasicObject.java:2695:in 'instance_eval'
-## org/jruby/RubyBasicObject.java:2723:in 'instance_eval'
-## /home/rbotafogo/desenv_linux/galaaz/lib/gknit/knitr_engine.rb:748:in 'block in initialize'
-## /home/rbotafogo/desenv_linux/galaaz/lib/R_interface/new_bridge_adapter.rb:358:in 'block in register_callback_proc_stub'
-## /home/rbotafogo/desenv_linux/galaaz/lib/new_bridge/session_client.rb:413:in 'block in handle_call'
+## *** Class Trajectories, method Show *** 
+## times = 1
+## 2
+## 3
+## 4
+## 5
+## 6
+## 7
+## 8
+## 9
+## 10
+## 12
+## 14
+## 16
+## 18
+## 20
+## 22
+## 24
+## 26
+## 28
+## 30
+## 32
+## * Traj (limited to a matrix 10x10) = 
+##       [,1]    [,2]    [,3]    [,4]    [,5]    [,6]    [,7]    [,8]   
+##  [1,] "16.08" "16.63" "16.39" "16.47" "16.60" "16.90" "17.07" "17.38"
+##  [2,] "16.35" "15.96" "16.29" "16.41" "16.65" "16.45" "17.23" "16.84"
+##  [3,] "15.70" "16.08" "16.70" "16.20" "16.67" "16.67" "16.94" "17.10"
+##  [4,] "15.94" "16.05" "16.30" "16.57" "16.48" "16.80" "16.95" "17.06"
+##  [5,] "16.06" "16.07" "16.33" "16.71" "16.91" "16.92" "17.22" "16.91"
+##  [6,] "16.17" "15.85" "16.61" "16.78" "16.41" "16.78" "17.00" "17.09"
+##  [7,] "16.03" "15.86" "16.46" "16.60" "16.80" "16.79" "16.97" "17.21"
+##  [8,] "16.24" "16.54" "16.21" "16.46" "16.81" "17.07" "16.67" "17.34"
+##  [9,] "15.89" "16.24" "16.30" "16.46" "16.53" "17.11" "17.06" "17.17"
+## [10,] "16.15" "16.06" "16.38" "16.10" "16.36" "16.94" "16.78" "17.08"
+##       [,9]    [,10]  
+##  [1,] "17.29" "17.29"
+##  [2,] "16.97" "17.13"
+##  [3,] "16.94" "17.47"
+##  [4,] "16.65" "17.61"
+##  [5,] "17.17" "17.49"
+##  [6,] "16.98" "17.87"
+##  [7,] "17.16" "17.29"
+##  [8,] "17.18" "17.48"
+##  [9,] "17.09" "17.18"
+## [10,] "17.69" "17.54"
+## ******* End Show (trajectories) *******
 \end{verbatim}
 
 Our show method has the same problem as SS4, i.e., if an empty
@@ -810,12 +867,1863 @@ an error. Let's see it:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\OtherTok{@empty\_traj}\AttributeTok{.show}
+\ControlFlowTok{begin}
+  \OtherTok{@empty\_traj}\AttributeTok{.show}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF boxes.}
+  \FunctionTok{puts}\NormalTok{ e}\AttributeTok{.class.to\_s}
+  \CommentTok{\# Wrap long messages for PDF code{-}box width.}
+\NormalTok{  e}\AttributeTok{.message.to\_s.scan}\NormalTok{(}\SpecialStringTok{/.\{1,68\}/}\NormalTok{)}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{line}\OperatorTok{|} \FunctionTok{puts}\NormalTok{ line }\OperatorTok{\}}
+\ControlFlowTok{end}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
+## *** Class Trajectories, method Show *** 
+## times = 
+## NoMethodError
 ## undefined method 'nrow' for nil
 \end{verbatim}
 
+In this example, \texttt{@matrix} is \texttt{nil}, so calling
+\texttt{@matrix.nrow} raises
+\texttt{undefined\ method\ \textquotesingle{}nrow\textquotesingle{}\ for\ nil}.
+To fix this, we can either prevent an empty trajectories class from
+being created, or make sure that method \texttt{show} will not choke on
+the empty object. We will take the second alternative, to follow SS4,
+and will check if either \texttt{@times} or \texttt{@matrix} is empty.
+If either one of them is \texttt{nil}, then we will print a message
+saying so.
+
+Although the first alternative, i.e., not allow for empty objects is a
+possibility in Ruby, it seems that this is not the case for S4.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def}\NormalTok{ show}
+    \ControlFlowTok{if}\NormalTok{ (}\OtherTok{@times}\AttributeTok{.nil?} \OperatorTok{||} \OtherTok{@matrix}\AttributeTok{.nil?}\NormalTok{)}
+      \FunctionTok{puts}\NormalTok{(}\StringTok{"*** Class Trajectories is empty!! *** "}\NormalTok{)}
+      \ControlFlowTok{return}
+    \ControlFlowTok{end}
+    \FunctionTok{puts}\NormalTok{(}\StringTok{"*** Class Trajectories, method Show *** "}\NormalTok{)}
+    \DataTypeTok{Kernel}\AttributeTok{.print}\NormalTok{(}\StringTok{"times = "}\NormalTok{)}
+    \FunctionTok{puts} \OtherTok{@times}
+\NormalTok{    nrow\_show }\OperatorTok{=} \KeywordTok{[}\DecValTok{10}\NormalTok{, }\OtherTok{@matrix}\AttributeTok{.nrow} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\KeywordTok{]}\AttributeTok{.min}
+\NormalTok{    ncol\_show }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.min}\NormalTok{(}\DecValTok{10}\NormalTok{, }\OtherTok{@matrix}\AttributeTok{.ncol}\NormalTok{) }\OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}
+    \FunctionTok{puts}\NormalTok{(}\StringTok{"* Traj (limited to a matrix 10x10) = "}\NormalTok{)}
+    \FunctionTok{puts} \OtherTok{@matrix}\KeywordTok{[}\NormalTok{(}\DecValTok{1}\OperatorTok{..}\NormalTok{nrow\_show), (}\DecValTok{1}\OperatorTok{..}\NormalTok{ncol\_show)}\KeywordTok{]}\AttributeTok{.format}\NormalTok{(}\WarningTok{digits:} \DecValTok{2}\NormalTok{,}
+      \WarningTok{nsmall:} \DecValTok{2}\NormalTok{)}
+    \FunctionTok{puts}\NormalTok{(}\StringTok{"******* End Show (trajectories) ******* "}\NormalTok{)}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@empty\_traj}\AttributeTok{.show}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## *** Class Trajectories is empty!! ***
+\end{verbatim}
+
+\section{To Remove an Object}\label{to-remove-an-object}
+
+As far as I know, there isn't a good way of removing a defined class,
+but there might be one and the interested user is directed to google it!
+In principle, there should not be any real need to remove a defined
+class. Both in R and Galaaz, large programs are usually written in a
+file and the file loaded. If one writes a wrong class, the better
+solution is to correct it and then load it again. If the class is
+written directly on the console, then leaving it there will not have any
+serious impact.
+
+\section{Method count\_missing}\label{method-count_missing}
+
+In R, methods `print' and `show' are methods that already exist. SS4
+wants to add a method called `countMissing' which does not exist in R,
+and thus requires some special preparation. In Ruby, every method we've
+created is a new method that exists inside the class. The fact that
+`print' happens to be also a method for class Kernel and `show' is not,
+is not of special interest. Actually we've seen that in order to call
+method print from the Kernel class we had to call Kernel.print.
+
+To create method `count\_missing' we just need to reopen the
+Trajectories class and add the method the same way we've done with
+method `show'. Again, let's first look at R's `countMissing' and then at
+Ruby's:
+
+\begin{verbatim}
+> setMethod(
++ f= "countMissing",
++ signature= "Trajectories",
++ definition=function(object){
++ return(sum(is.na(object@traj)))
++ }
++ )
+\end{verbatim}
+
+Here we introduce another particular case of Galaaz. R has many methods
+that have a `.' in their names, such as `is.na'. In Ruby, the dot `.'
+has a special meaning as it is the way we call a method on an object.
+Doing `R.is.na' will not work. So, in Galaaz, R functions that have a
+dot in them will have the dot substituted by '\_\_'. So, method is.na in
+Galaaz, becomes R.is\_\_na. In method count\_missing we use method
+chaining and convert the final count to a Ruby number with
+\texttt{\textgreater{}\textgreater{}\ 0} (unbox).
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def}\NormalTok{ count\_missing}
+    \ControlFlowTok{return} \OtherTok{@matrix}\AttributeTok{.is\_\_na.sum} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@trajCochin}\AttributeTok{.count\_missing}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## 1
+\end{verbatim}
+
+\section{To See the Methods}\label{to-see-the-methods}
+
+In order to see the methods we have defined so far, we call on class
+Trajectories the method `instance\_methods' passing it one argument,
+`false', as follows:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \DataTypeTok{Trajectories}\AttributeTok{.instance\_methods}\NormalTok{(}\DecValTok{false}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## count_missing
+## times
+## print
+## show
+## matrix
+\end{verbatim}
+
+It is interesting to observe that we see our three methods
+`count\_missing', `print' and `show', but we also see two other methods
+`times' and `matrix', but those last two as far as we know are just
+instance variables and not methods, right? More on that when we talk
+about Accessors.
+
+Galaaz and Ruby do not by default provide a way to see a method's code.
+However, if the user uses a Ruby console such as Pry, then seeing
+methods and debugging is possible. Pry is beyond the scope of this
+document.
+
+\section{Construction}\label{construction}
+
+Every class in Ruby has a constructor, if not explicitly defined, at
+least implicitly. Method initialize is the constructor method and the
+one that coordinates the whole construction process.
+
+\section{Inspector}\label{inspector}
+
+There is no default `inspector' in Ruby as in R, although there is
+nothing that prevents the developer from inspecting and validating the
+input. For example, in the object Trajectories, one may want to check
+that the number of elements in `times' is equal to the number of columns
+in `matrix' and if they are not, issue an error. In order to understand
+why this restriction exists, the user is again directed to SS4.
+
+Here we show the R code for this validation:
+
+\begin{verbatim}
+> setClass(
++ Class="Trajectories",
++ representation(times="numeric",traj="matrix"),
++ validity=function(object){
++ cat("~~~ Trajectories: inspector ~~~ \\n")
++ if(length(object@times)!=ncol(object@traj)){
++ stop ("[Trajectories: validation] the number of temporal
++ measurements does not correspond
++ }else{}
++ return(TRUE)
++ }
++ )
+\end{verbatim}
+
+In order to implement this validation we will coordinate it in the
+initialize method.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(times}\OperatorTok{:} \DecValTok{nil}\NormalTok{, }\WarningTok{matrix:} \DecValTok{nil}\NormalTok{)}
+    \OtherTok{@times} \OperatorTok{=}\NormalTok{ times}
+    \OtherTok{@matrix} \OperatorTok{=}\NormalTok{ matrix}
+
+    \CommentTok{\# Validate: length(@times) must equal ncol(@matrix)}
+    \FunctionTok{puts}\NormalTok{ (}\StringTok{"\textasciitilde{}\textasciitilde{}\textasciitilde{} Trajectories: inspector \textasciitilde{}\textasciitilde{}\textasciitilde{} "}\NormalTok{)}
+    \ControlFlowTok{if}\NormalTok{ ((}\OtherTok{@times}\AttributeTok{.length} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{) }\OperatorTok{!=}\NormalTok{ (}\OtherTok{@matrix}\AttributeTok{.ncol} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{))}
+      \FunctionTok{raise}\NormalTok{(}
+        \StringTok{"[Trajectories: validation] the number of temporal "} \OperatorTok{+}
+        \StringTok{"measurements does not correspond with the number of "} \OperatorTok{+}
+        \StringTok{"columns in the matrix"}\NormalTok{)}
+    \ControlFlowTok{end}
+
+    \CommentTok{\# show the object just created}
+\NormalTok{    show}
+
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+Let's first create a Trajectories that validates fine, i.e., the number
+of elements in @times is equal to the number of columns of the matrix.
+In this case, we will show a message saying that validation was done and
+then print the object.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{ok }\OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\OperatorTok{..}\DecValTok{2}\NormalTok{), }\WarningTok{matrix:} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{2}\NormalTok{),}
+  \WarningTok{ncol:} \DecValTok{2}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~~~ Trajectories: inspector ~~~ 
+## *** Class Trajectories, method Show *** 
+## times = 1
+## 2
+## * Traj (limited to a matrix 10x10) = 
+## 1
+## 2
+## ******* End Show (trajectories) *******
+\end{verbatim}
+
+Now, if we try to create a Trajectories that does not pass the
+validation criteria, our code will raise an exception. Exceptions are a
+standard way to deal with errors in Ruby code and many other object
+oriented languages. The interested reader should look for further
+documentation on exceptions on the web.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{begin}
+\NormalTok{  error }\OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\OperatorTok{..}\DecValTok{3}\NormalTok{), }\WarningTok{matrix:} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{2}\NormalTok{),}
+    \WarningTok{ncol:} \DecValTok{2}\NormalTok{))}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF boxes.}
+  \FunctionTok{puts}\NormalTok{ e}\AttributeTok{.class.to\_s}
+  \CommentTok{\# Wrap long messages for PDF code{-}box width.}
+\NormalTok{  e}\AttributeTok{.message.to\_s.scan}\NormalTok{(}\SpecialStringTok{/.\{1,68\}/}\NormalTok{)}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{line}\OperatorTok{|} \FunctionTok{puts}\NormalTok{ line }\OperatorTok{\}}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~~~ Trajectories: inspector ~~~ 
+## RuntimeError
+## [Trajectories: validation] the number of temporal measurements does 
+## not correspond with the number of columns in the matrix
+\end{verbatim}
+
+The validation above does not consider the case when an empty object is
+created. Here we will check to see if either times or matrix are nil; if
+either one of them is nil, then we will raise an exception and interrupt
+the creation of the object. We also create a method validate that is
+called from our initialize method.
+
+Method validate has some interesting features about the integration of
+Galaaz and R. We compare lengths after unboxing with
+\texttt{\textgreater{}\textgreater{}\ 0}, so the comparison is ordinary
+Ruby arithmetic on numbers. (A length-1 R logical can likewise be
+treated as a Ruby boolean via \texttt{\textgreater{}\textgreater{}\ 0}.)
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(times}\OperatorTok{:} \DecValTok{nil}\NormalTok{, }\WarningTok{matrix:} \DecValTok{nil}\NormalTok{)}
+    \OtherTok{@times} \OperatorTok{=}\NormalTok{ times}
+    \OtherTok{@matrix} \OperatorTok{=}\NormalTok{ matrix}
+
+    \CommentTok{\# call method validate to validate our input}
+\NormalTok{    validate}
+
+    \CommentTok{\# show the object just created}
+\NormalTok{    show}
+
+  \ControlFlowTok{end}
+
+  \ControlFlowTok{def}\NormalTok{ validate}
+
+    \CommentTok{\# Let\textquotesingle{}s first check that we do not have an empty object}
+    \ControlFlowTok{if}\NormalTok{ (}\OtherTok{@times}\AttributeTok{.nil?} \OperatorTok{||} \OtherTok{@matrix}\AttributeTok{.nil?}\NormalTok{)}
+      \FunctionTok{raise} \StringTok{"Neither times nor matrix can be an empty object"}
+    \ControlFlowTok{end}
+
+    \CommentTok{\# Validate: length(@times) must equal ncol(@matrix)}
+    \FunctionTok{puts}\NormalTok{ (}\StringTok{"\textasciitilde{}\textasciitilde{}\textasciitilde{} Trajectories: inspector \textasciitilde{}\textasciitilde{}\textasciitilde{} "}\NormalTok{)}
+    \ControlFlowTok{if}\NormalTok{ ((}\OtherTok{@times}\AttributeTok{.length} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{) }\OperatorTok{!=}\NormalTok{ (}\OtherTok{@matrix}\AttributeTok{.ncol} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{))}
+      \FunctionTok{raise}\NormalTok{(}
+        \StringTok{"[Trajectories: validation] the number of temporal "} \OperatorTok{+}
+        \StringTok{"measurements does not correspond with the number of "} \OperatorTok{+}
+        \StringTok{"columns in the matrix"}\NormalTok{)}
+    \ControlFlowTok{end}
+
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\textbf{Note:} with this stricter \texttt{validate},
+\texttt{Trajectories.new} no longer accepts empty objects. The earlier
+\texttt{@empty\_traj\ =\ Trajectories.new} / \texttt{@empty\_traj.show}
+pattern from part 1 no longer applies for \emph{new} constructions;
+existing instances created before this reopen still exist in memory, but
+calling \texttt{new} with missing \texttt{times} or \texttt{matrix} will
+raise.
+
+Let's try then creating an empty object:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{begin}
+\NormalTok{  error }\OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF boxes.}
+  \FunctionTok{puts}\NormalTok{ e}\AttributeTok{.class.to\_s}
+  \CommentTok{\# Wrap long messages for PDF code{-}box width.}
+\NormalTok{  e}\AttributeTok{.message.to\_s.scan}\NormalTok{(}\SpecialStringTok{/.\{1,68\}/}\NormalTok{)}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{line}\OperatorTok{|} \FunctionTok{puts}\NormalTok{ line }\OperatorTok{\}}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## RuntimeError
+## Neither times nor matrix can be an empty object
+\end{verbatim}
+
+Another example:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{begin}
+\NormalTok{  error }\OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \DecValTok{1}\NormalTok{)}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF boxes.}
+  \FunctionTok{puts}\NormalTok{ e}\AttributeTok{.class.to\_s}
+  \CommentTok{\# Wrap long messages for PDF code{-}box width.}
+\NormalTok{  e}\AttributeTok{.message.to\_s.scan}\NormalTok{(}\SpecialStringTok{/.\{1,68\}/}\NormalTok{)}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{line}\OperatorTok{|} \FunctionTok{puts}\NormalTok{ line }\OperatorTok{\}}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## RuntimeError
+## Neither times nor matrix can be an empty object
+\end{verbatim}
+
+Let's see now that the implementation is correct and that it does not
+raise an error on valid input:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{ok }\OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{), }\WarningTok{matrix:} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{2}\NormalTok{),}
+  \WarningTok{ncol:} \DecValTok{2}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~~~ Trajectories: inspector ~~~ 
+## *** Class Trajectories, method Show *** 
+## times = 1
+## 2
+## * Traj (limited to a matrix 10x10) = 
+## 1
+## 2
+## ******* End Show (trajectories) *******
+\end{verbatim}
+
+The `initialize' method is called ONLY during the initial creation of
+the object. If any instance variable is later modified, no control is
+done. At this moment though, there is no way to change the value of any
+of our instance variables.
+
+\begin{verbatim}
+error.times = R.c(1, 2, 3)
+\end{verbatim}
+
+The Trajectories class works for R objects and expects as input R
+objects. Passing R objects in all examples has been the obligation of
+the programmer. Galaaz, however, can also accept many Ruby values
+(ranges, arrays of numbers, and so on) if we convert them at the
+boundary. There is no \texttt{R.convert} in Galaaz 2.0; a small helper
+is enough: leave \texttt{nil} alone, keep objects that are already
+\texttt{R::Object}, and otherwise wrap with \texttt{R.c} (which accepts
+ranges as well as scalars and vectors). Matrices that are already R
+objects are kept as-is.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def}\NormalTok{ as\_r(x)}
+    \ControlFlowTok{return} \DecValTok{nil} \ControlFlowTok{if}\NormalTok{ x}\AttributeTok{.nil?}
+    \ControlFlowTok{return}\NormalTok{ x }\ControlFlowTok{if}\NormalTok{ x}\AttributeTok{.is\_a?}\NormalTok{(}\ConstantTok{R}\OperatorTok{::}\DataTypeTok{Object}\NormalTok{)}
+    \ConstantTok{R}\AttributeTok{.c}\NormalTok{(x)}
+  \ControlFlowTok{end}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(times}\OperatorTok{:} \DecValTok{nil}\NormalTok{, }\WarningTok{matrix:} \DecValTok{nil}\NormalTok{)}
+    \OtherTok{@times} \OperatorTok{=}\NormalTok{ as\_r(times)}
+    \OtherTok{@matrix} \OperatorTok{=}\NormalTok{ as\_r(matrix)}
+
+    \CommentTok{\# call method validate to validate our input}
+\NormalTok{    validate}
+
+    \CommentTok{\# show the object just created}
+\NormalTok{    show}
+
+  \ControlFlowTok{end}
+
+  \ControlFlowTok{def}\NormalTok{ validate}
+
+    \CommentTok{\# Let\textquotesingle{}s first check that we do not have an empty object}
+    \ControlFlowTok{if}\NormalTok{ (}\OtherTok{@times}\AttributeTok{.nil?} \OperatorTok{||} \OtherTok{@matrix}\AttributeTok{.nil?}\NormalTok{)}
+      \FunctionTok{raise} \StringTok{"Neither times nor matrix can be an empty object"}
+    \ControlFlowTok{end}
+
+    \CommentTok{\# Validate: length(@times) must equal ncol(@matrix)}
+    \FunctionTok{puts}\NormalTok{ (}\StringTok{"\textasciitilde{}\textasciitilde{}\textasciitilde{} Trajectories: inspector \textasciitilde{}\textasciitilde{}\textasciitilde{} "}\NormalTok{)}
+\NormalTok{    tl }\OperatorTok{=} \OtherTok{@times}\AttributeTok{.length} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{; mc }\OperatorTok{=} \OtherTok{@matrix}\AttributeTok{.ncol} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}
+    \ControlFlowTok{if}\NormalTok{ (tl }\OperatorTok{!=}\NormalTok{ mc)}
+      \FunctionTok{raise}\NormalTok{(}
+        \StringTok{"[Trajectories: validation] the number of temporal "} \OperatorTok{+}
+        \StringTok{"measurements }\SpecialCharTok{\#\{}\NormalTok{tl}\SpecialCharTok{\}}\StringTok{ does not correspond with the number "} \OperatorTok{+}
+        \StringTok{"of columns in the matrix }\SpecialCharTok{\#\{}\NormalTok{mc}\SpecialCharTok{\}}\StringTok{"}\NormalTok{)}
+    \ControlFlowTok{end}
+
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+And now let's create a new Trajectories, but we will now pass a Ruby
+range for times:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{ok }\OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:}\NormalTok{ (}\DecValTok{1}\OperatorTok{..}\DecValTok{2}\NormalTok{), }\WarningTok{matrix:} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{2}\NormalTok{), }\WarningTok{ncol:} \DecValTok{2}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~~~ Trajectories: inspector ~~~ 
+## *** Class Trajectories, method Show *** 
+## times = 1
+## 2
+## * Traj (limited to a matrix 10x10) = 
+## 1
+## 2
+## ******* End Show (trajectories) *******
+\end{verbatim}
+
+Perfect! This works fine.
+
+\emph{(Historical note: an earlier Galaaz prototype on Renjin also
+demonstrated sharing storage with the MDArray gem. Those shared-store
+demos are not part of Galaaz 2.0 / the GNU R bridge, and are omitted
+here.)}
+
+\section{The Initializator}\label{the-initializator}
+
+As we have seen, method `initialize' is the main object creator
+orchestrator. This method can be as complex as needed. So, let's get on
+with some improvements to our Trajectories class.
+
+It would be rather pleasant that the columns of the matrix of the
+trajectories have names, the names of measurements times. In the same
+way, the lines could be subscripted by a number of individual.
+
+To do this in R, one also uses method initialize:
+
+\begin{verbatim}
+> setMethod(
++ f="initialize",
++ signature="Trajectories",
++ definition=function(.Object,times,traj){
++ cat("~~~ Trajectories: initializator ~~~ \\n")
++ colnames(traj) <- paste("T",times,sep="")
++ rownames(traj) <- paste("I",1:nrow(traj),sep= "")
++ .Object@traj <- traj # Assignment of the slots
++ .Object@times <- times
++ return(.Object) # return of the object
++ }
++ )
+\end{verbatim}
+
+In R, it is possible to assign a value to the result of a function, for
+example \texttt{colnames(x)\ \textless{}-\ c("v1",\ "v2",\ "v3")}. In
+Galaaz 2.0 the same idea is expressed with ordinary Ruby setters on the
+R object: \texttt{@matrix.colnames\ =\ ...} and
+\texttt{@matrix.rownames\ =\ ...}.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def}\NormalTok{ as\_r(x)}
+    \ControlFlowTok{return} \DecValTok{nil} \ControlFlowTok{if}\NormalTok{ x}\AttributeTok{.nil?}
+    \ControlFlowTok{return}\NormalTok{ x }\ControlFlowTok{if}\NormalTok{ x}\AttributeTok{.is\_a?}\NormalTok{(}\ConstantTok{R}\OperatorTok{::}\DataTypeTok{Object}\NormalTok{)}
+    \ConstantTok{R}\AttributeTok{.c}\NormalTok{(x)}
+  \ControlFlowTok{end}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(times}\OperatorTok{:} \DecValTok{nil}\NormalTok{, }\WarningTok{matrix:} \DecValTok{nil}\NormalTok{)}
+    \OtherTok{@times} \OperatorTok{=}\NormalTok{ as\_r(times)}
+    \OtherTok{@matrix} \OperatorTok{=}\NormalTok{ as\_r(matrix)}
+
+    \CommentTok{\# call method validate to validate our input}
+\NormalTok{    validate}
+
+    \CommentTok{\# Add row and column names}
+    \FunctionTok{puts}\NormalTok{ (}\StringTok{"\textasciitilde{}\textasciitilde{}\textasciitilde{} Trajectories: initializator \textasciitilde{}\textasciitilde{}\textasciitilde{} "}\NormalTok{)}
+    \OtherTok{@matrix}\AttributeTok{.colnames} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.paste}\NormalTok{(}\StringTok{"T"}\NormalTok{, }\OtherTok{@times}\NormalTok{, }\WarningTok{sep:} \StringTok{""}\NormalTok{)}
+    \OtherTok{@matrix}\AttributeTok{.rownames} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.paste}\NormalTok{(}\StringTok{"I"}\NormalTok{, (}\DecValTok{1}\OperatorTok{..}\NormalTok{(}\OtherTok{@matrix}\AttributeTok{.nrow} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{)), }\WarningTok{sep:} \StringTok{""}\NormalTok{)}
+
+    \CommentTok{\# show the object just created}
+\NormalTok{    show}
+
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@traj} \OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{2}\NormalTok{,}\DecValTok{4}\NormalTok{,}\DecValTok{8}\NormalTok{), }\WarningTok{matrix:} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{8}\NormalTok{),}
+  \WarningTok{nrow:} \DecValTok{2}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~~~ Trajectories: inspector ~~~ 
+## ~~~ Trajectories: initializator ~~~ 
+## *** Class Trajectories, method Show *** 
+## times = 1
+## 2
+## 4
+## 8
+## * Traj (limited to a matrix 10x10) = 
+##    T1  T2  T4  T8 
+## I1 "1" "3" "5" "7"
+## I2 "2" "4" "6" "8"
+## ******* End Show (trajectories) *******
+\end{verbatim}
+
+Note that we still call our `validate' method and it is still an error
+to create an empty Trajectories or one in which the sizes are wrong:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{begin}
+\NormalTok{  error }\OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{48}\NormalTok{), }\WarningTok{matrix:} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{8}\NormalTok{),}
+    \WarningTok{nrow:} \DecValTok{2}\NormalTok{))}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF boxes.}
+  \FunctionTok{puts}\NormalTok{ e}\AttributeTok{.class.to\_s}
+  \CommentTok{\# Wrap long messages for PDF code{-}box width.}
+\NormalTok{  e}\AttributeTok{.message.to\_s.scan}\NormalTok{(}\SpecialStringTok{/.\{1,68\}/}\NormalTok{)}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{line}\OperatorTok{|} \FunctionTok{puts}\NormalTok{ line }\OperatorTok{\}}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~~~ Trajectories: inspector ~~~ 
+## RuntimeError
+## [Trajectories: validation] the number of temporal measurements 3 doe
+## s not correspond with the number of columns in the matrix 4
+\end{verbatim}
+
+A constructor does not necessarily take the instance variable of the
+object as argument. For example, if we know (that is not the case in
+reality, but let us imagine so) that the BMI increases by 0.1 every
+week, we could build trajectories by providing the number of weeks and
+the initial weights.
+
+First the code in R, we skip the definition of class TrajectoriesBis:
+
+\begin{verbatim}
+> setMethod ("initialize",
++ "TrajectoriesBis",
++ function(.Object,nbWeek,BMIinit){
++ traj <- outer(BMIinit, 1:nbWeek,
++   function(init, week) { return(init + 0.1 * week) })
++ colnames(traj) <- paste("T",1:nbWeek,sep="")
++ rownames(traj) <- paste("I",1:nrow(traj),sep="")
++ .Object@times <- 1:nbWeek
++ .Object@traj <- traj
++ return(.Object)
++ }
++ )
+\end{verbatim}
+
+Now, let's make a TrajectoriesBis in Galaaz. Here again, we should point
+out some characteristics of our code:
+
+\begin{itemize}
+\item
+  We made initialize with two positional arguments, instead of named
+  arguments, i.e., the first argument is the number of weeks and the
+  second bmi\_init. In this case, when making a new object the position
+  of the arguments is important and there is no way to pass the argument
+  by name;
+\item
+  R function outer was called as if a method from bmi\_init using dot
+  notation, although one could use R.outer without problem;
+\item
+  Function `outer' expects an R function as its 3rd argument. In order
+  to build an R function from Galaaz, we need to pass the function
+  definition as a string to R.eval.
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{TrajectoriesBis}
+
+  \OtherTok{attr\_reader} \WarningTok{:times}
+  \OtherTok{attr\_reader} \WarningTok{:matrix}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(number\_weeks, bmi\_init)}
+    \OtherTok{@matrix} \OperatorTok{=}\NormalTok{ bmi\_init}\AttributeTok{.outer}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\NormalTok{number\_weeks),}
+                             \ConstantTok{R}\AttributeTok{.eval}\NormalTok{(}\StringTok{"function(init,}
+\StringTok{                               week) \{return(init + 0.1 * week)\}"}\NormalTok{))}
+    \OtherTok{@times} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\NormalTok{number\_weeks))}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+
+\OtherTok{@traj\_bis} \OperatorTok{=} \DataTypeTok{TrajectoriesBis}\AttributeTok{.new}\NormalTok{(}\DecValTok{4}\NormalTok{, }\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{16}\NormalTok{,}\DecValTok{17}\NormalTok{,}\FloatTok{15.6}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@traj\_bis}\AttributeTok{.matrix}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      [,1] [,2] [,3] [,4]
+## [1,] 16.1 16.2 16.3 16.4
+## [2,] 17.1 17.2 17.3 17.4
+## [3,] 15.7 15.8 15.9 16.0
+\end{verbatim}
+
+It is always possible to pass a Ruby variable into a string by
+interpolating it. Put the variable inside \texttt{\#\{...\}}. As an
+example, let's also require the BMI increase as a parameter. (A common
+mistake is to escape the interpolation --- writing
+\texttt{\textbackslash{}\#\{increment\}} --- which leaves the characters
+literally in the R source and does not substitute the Ruby value. Use
+real interpolation:)
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{TrajectoriesBis}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(number\_weeks, bmi\_init, increment)}
+    \OtherTok{@matrix} \OperatorTok{=}\NormalTok{ bmi\_init}\AttributeTok{.outer}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\NormalTok{number\_weeks),}
+                             \ConstantTok{R}\AttributeTok{.eval}\NormalTok{(}\StringTok{"function(init,}
+\StringTok{                               week) \{return(init +}
+\StringTok{                                 }\SpecialCharTok{\#\{}\NormalTok{increment}\SpecialCharTok{\}}\StringTok{ * week)\}"}\NormalTok{))}
+    \OtherTok{@times} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\NormalTok{number\_weeks))}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+
+\OtherTok{@traj\_bis} \OperatorTok{=} \DataTypeTok{TrajectoriesBis}\AttributeTok{.new}\NormalTok{(}\DecValTok{4}\NormalTok{, }\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{16}\NormalTok{,}\DecValTok{17}\NormalTok{,}\FloatTok{15.6}\NormalTok{), }\FloatTok{0.3}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@traj\_bis}\AttributeTok{.matrix}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      [,1] [,2] [,3] [,4]
+## [1,] 16.3 16.6 16.9 17.2
+## [2,] 17.3 17.6 17.9 18.2
+## [3,] 15.9 16.2 16.5 16.8
+\end{verbatim}
+
+\section{Constructors for Users}\label{constructors-for-users}
+
+Many times, it is interesting to have different ways of constructing an
+object depending on what information our users have or want to provide
+to the constructor. Although we have only one initialize method, we can
+create multiple methods, that do some preprocessing and then call the
+initialize method to carry out the object building.
+
+In order to do that, we use what are called class methods, instead of
+instance methods. All the methods we've created so far are instance
+methods; class methods are defined by prepending the self keyword to the
+method's name. Still using the assumption that the BMI will grow by 0.1
+per week, let's define a regular trajectory without having to define a
+TrajectoriesBis as above:
+
+\begin{verbatim}
+> regularTrajectories <- function(nbWeek,BMIinit) {
++ traj <- outer(BMIinit, 1:nbWeek,
++   function(init, week) { return(init + 0.1 * week) })
++ times <- 1: nbWeek
++ return(new(Class="Trajectories",times=times,traj=traj))
++ }
+> regularTrajectories(nbWeek=3,BMIinit=c(14,15,16))
+\end{verbatim}
+
+Notice how method `regular' is defined as `self.regular', making it a
+class method. The last statement of the method definition is actually a
+call to the Trajectories constructor `new' passing the calculated values
+for times and matrix.
+
+Notice also how method regular is called, similar to the way new is
+called by adding it after class Trajectories name:
+`Trajectories.regular'.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def} \DecValTok{self}\AttributeTok{.regular}\NormalTok{(}\WarningTok{number\_weeks:} \DecValTok{nil}\NormalTok{, }\WarningTok{bmi\_init:} \DecValTok{nil}\NormalTok{)}
+\NormalTok{    matrix }\OperatorTok{=}\NormalTok{ bmi\_init}\AttributeTok{.outer}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\NormalTok{number\_weeks),}
+                            \ConstantTok{R}\AttributeTok{.eval}\NormalTok{(}\StringTok{"function(init,}
+\StringTok{                              week) \{return(init + 0.1 * week)\}"}\NormalTok{))}
+\NormalTok{    times }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\NormalTok{number\_weeks))}
+    \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:}\NormalTok{ times, }\WarningTok{matrix:}\NormalTok{ matrix)}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@regular} \OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.regular}\NormalTok{(}\WarningTok{bmi\_init:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{14}\NormalTok{, }\DecValTok{15}\NormalTok{, }\DecValTok{16}\NormalTok{),}
+  \WarningTok{number\_weeks:} \DecValTok{3}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~~~ Trajectories: inspector ~~~ 
+## ~~~ Trajectories: initializator ~~~ 
+## *** Class Trajectories, method Show *** 
+## times = 1
+## 2
+## 3
+## * Traj (limited to a matrix 10x10) = 
+##    T1      T2      T3     
+## I1 "14.10" "14.20" "14.30"
+## I2 "15.10" "15.20" "15.30"
+## I3 "16.10" "16.20" "16.30"
+## ******* End Show (trajectories) *******
+\end{verbatim}
+
+We have already seen that constructors can be as complex as needed,
+calling other methods and doing calculations on the received parameters.
+On this last example, we will check if the times variable was provided.
+If it is not provided, then we will use matrix columns to define the
+times:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def} \DecValTok{self}\AttributeTok{.init}\NormalTok{(}\WarningTok{times:} \DecValTok{nil}\NormalTok{, }\WarningTok{matrix:} \DecValTok{nil}\NormalTok{)}
+\NormalTok{    times }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\NormalTok{(matrix}\AttributeTok{.ncol} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{))) }\ControlFlowTok{if}\NormalTok{ times}\AttributeTok{.nil?}
+    \DataTypeTok{Trajectories}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:}\NormalTok{ times, }\WarningTok{matrix:}\NormalTok{ matrix)}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@traj} \OperatorTok{=} \DataTypeTok{Trajectories}\AttributeTok{.init}\NormalTok{(}\WarningTok{matrix:} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{8}\NormalTok{), }\WarningTok{ncol:} \DecValTok{4}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~~~ Trajectories: inspector ~~~ 
+## ~~~ Trajectories: initializator ~~~ 
+## *** Class Trajectories, method Show *** 
+## times = 1
+## 2
+## 3
+## 4
+## * Traj (limited to a matrix 10x10) = 
+##    T1  T2  T3  T4 
+## I1 "1" "3" "5" "7"
+## I2 "2" "4" "6" "8"
+## ******* End Show (trajectories) *******
+\end{verbatim}
+
+\section{Accessors}\label{accessors}
+
+Accessors are methods for getting and setting the value of instance
+variables.
+
+\section{Get}\label{get}
+
+Getters are methods for getting the value of an instance variable. We
+have been using getters since the beginning of this document, without
+explicitly saying so. When defining attr\_reader :times and attr\_reader
+:matrix, we have actually defined two getter methods for reading the
+values of variables times and matrix respectively. We can however define
+getters explicitly:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{TrajectoriesBis}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(times}\OperatorTok{:} \DecValTok{nil}\NormalTok{, }\WarningTok{matrix:} \DecValTok{nil}\NormalTok{)}
+    \OtherTok{@times} \OperatorTok{=}\NormalTok{ times}
+    \OtherTok{@matrix} \OperatorTok{=}\NormalTok{ matrix}
+  \ControlFlowTok{end}
+
+  \ControlFlowTok{def}\NormalTok{ times}
+    \OtherTok{@times}
+  \ControlFlowTok{end}
+
+  \ControlFlowTok{def}\NormalTok{ matrix}
+    \OtherTok{@matrix}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+
+\OtherTok{@traj} \OperatorTok{=} \DataTypeTok{TrajectoriesBis}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \DecValTok{1}\NormalTok{, }\WarningTok{matrix:} \DecValTok{2}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@traj}\AttributeTok{.times}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## 1
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@traj}\AttributeTok{.matrix}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## 2
+\end{verbatim}
+
+It is also possible to define more sophisticated getters. For example
+one can regularly need the BMI at inclusion. In R, one would index a
+matrix as matrix{[},1{]}. In Ruby, it is a syntax error to have a `,'
+just after the `{[}'. In this case we need to add `nil' as in
+matrix{[}nil, 1{]}:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def}\NormalTok{ get\_traj\_inclusion}
+    \OtherTok{@matrix}\KeywordTok{[}\DecValTok{nil}\NormalTok{, }\DecValTok{1}\KeywordTok{]}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@trajCochin}\AttributeTok{.get\_traj\_inclusion}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## numeric(0)
+\end{verbatim}
+
+\section{Set}\label{set}
+
+A setter is a method that assigns a value to a variable. As with
+getters, Ruby also provides an easy way to write setters and allow you
+to also write them explicitly. Let's first use the simple way:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{TrajectoriesBis}
+
+  \OtherTok{attr\_writer} \WarningTok{:times}
+  \OtherTok{attr\_writer} \WarningTok{:matrix}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(times}\OperatorTok{:} \DecValTok{nil}\NormalTok{, }\WarningTok{matrix:} \DecValTok{nil}\NormalTok{)}
+    \OtherTok{@times} \OperatorTok{=}\NormalTok{ times}
+    \OtherTok{@matrix} \OperatorTok{=}\NormalTok{ matrix}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+
+\OtherTok{@traj} \OperatorTok{=} \DataTypeTok{TrajectoriesBis}\AttributeTok{.new}
+\OtherTok{@traj}\AttributeTok{.times} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{)}
+\OtherTok{@traj}\AttributeTok{.matrix} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{((}\DecValTok{1}\OperatorTok{..}\DecValTok{2}\NormalTok{), }\WarningTok{ncol:} \DecValTok{2}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@traj}\AttributeTok{.matrix}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##      [,1] [,2]
+## [1,]    1    2
+\end{verbatim}
+
+Note that now we can use `=' to assign a value to both variables times
+and matrix. Without setters, changing the value of variables times and
+matrix was not possible. Our class, up to this point was protected from
+any changes to those variables. If we need to allow changes to those
+variables, then setters are needed. In this case, the simple setter as
+shown above is not ideal, since it would allow changes that break the
+restriction that variable times has to have the same length as the
+number of columns of matrix. In order to do the verification we need to
+implement a more sophisticated setter. In the example below, we add the
+`times=' setter that receives as input one argument. First we convert
+the given argument to an R object, then check to see that the length of
+times is the same as the number of columns and if everything is fine,
+then we set the value of instance variable times:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def}\NormalTok{ as\_r(x)}
+    \ControlFlowTok{return} \DecValTok{nil} \ControlFlowTok{if}\NormalTok{ x}\AttributeTok{.nil?}
+    \ControlFlowTok{return}\NormalTok{ x }\ControlFlowTok{if}\NormalTok{ x}\AttributeTok{.is\_a?}\NormalTok{(}\ConstantTok{R}\OperatorTok{::}\DataTypeTok{Object}\NormalTok{)}
+    \ConstantTok{R}\AttributeTok{.c}\NormalTok{(x)}
+  \ControlFlowTok{end}
+
+  \ControlFlowTok{def}\NormalTok{ times}\OperatorTok{=}\NormalTok{(times)}
+\NormalTok{    times }\OperatorTok{=}\NormalTok{ as\_r(times)}
+\NormalTok{    tl }\OperatorTok{=}\NormalTok{ times}\AttributeTok{.length} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{; mc }\OperatorTok{=} \OtherTok{@matrix}\AttributeTok{.ncol} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}
+    \ControlFlowTok{if}\NormalTok{ (tl }\OperatorTok{!=}\NormalTok{ mc)}
+      \FunctionTok{raise}\NormalTok{(}
+        \StringTok{"[Trajectories: validation] the number of temporal "} \OperatorTok{+}
+        \StringTok{"measurements }\SpecialCharTok{\#\{}\NormalTok{tl}\SpecialCharTok{\}}\StringTok{ does not correspond with the number "} \OperatorTok{+}
+        \StringTok{"of columns in the matrix }\SpecialCharTok{\#\{}\NormalTok{mc}\SpecialCharTok{\}}\StringTok{"}\NormalTok{)}
+    \ControlFlowTok{end}
+    \OtherTok{@times} \OperatorTok{=}\NormalTok{ times}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{begin}
+  \OtherTok{@trajCochin}\AttributeTok{.times} \OperatorTok{=}\NormalTok{ (}\DecValTok{1}\OperatorTok{..}\DecValTok{5}\NormalTok{)}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF boxes.}
+  \FunctionTok{puts}\NormalTok{ e}\AttributeTok{.class.to\_s}
+  \CommentTok{\# Wrap long messages for PDF code{-}box width.}
+\NormalTok{  e}\AttributeTok{.message.to\_s.scan}\NormalTok{(}\SpecialStringTok{/.\{1,68\}/}\NormalTok{)}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{line}\OperatorTok{|} \FunctionTok{puts}\NormalTok{ line }\OperatorTok{\}}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## RuntimeError
+## [Trajectories: validation] the number of temporal measurements 5 doe
+## s not correspond with the number of columns in the matrix 4
+\end{verbatim}
+
+We now set the value appropriately and will not get any errors:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@trajCochin}\AttributeTok{.times} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{6}\NormalTok{, }\DecValTok{8}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\section{The Operator `{[}'}\label{the-operator}
+
+It is also possible to define getters by using the operator `{[}'. This
+operator is not usually used for returning instance variables and it is
+preferable to use the methods we've used above; however, for
+completeness with SS4 we are showing how to define this here. Operator
+`{[}' is better left to be used for array/matrix indices.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def} \WarningTok{[]}\NormalTok{(var\_name)}
+
+    \ControlFlowTok{case}\NormalTok{ var\_name}
+    \ControlFlowTok{when} \StringTok{"times"}
+      \OtherTok{@times}
+    \ControlFlowTok{when} \StringTok{"matrix"}
+      \OtherTok{@matrix}
+    \ControlFlowTok{else}
+      \FunctionTok{raise} \StringTok{"Unknown instance variable"}
+    \ControlFlowTok{end}
+
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@trajCochin}\KeywordTok{[}\StringTok{"times"}\KeywordTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 5 6 8
+\end{verbatim}
+
+Similarly, we could use operator `{[}{]}=' to assign a value to times
+and matrix. We will not do this here as we think that the other options
+are better and the interested user can easily find help, if needed to
+implement such method.
+
+\section{To Go Further}\label{to-go-further}
+
+This section will introduce advanced features of Object Oriented
+programming such as Inheritance and Modules and will also show some
+aspects of S4 that do not apply to Ruby.
+
+\section{Methods Using Several
+Arguments}\label{methods-using-several-arguments}
+
+In Ruby, methods can have as many arguments as needed and those methods
+are defined the way we have already seen in many of the examples above.
+The example in SS4 presents a method that prints different output if its
+input is numeric, character or both. Let's write a class in Ruby that
+does the same for Numeric and String. In Ruby we do not define global
+functions, we always define methods inside classes or modules (as we
+will see later). Also, Ruby is not typed, so methods are not called
+depending on their types as in SS4 examples. Below, method test will be
+called with one parameter. At the time of calling we do not know the
+type of the argument; the method can then check if the received argument
+is a Numeric or a String and at this time, decide what should be
+printed.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Test}
+
+  \ControlFlowTok{def} \FunctionTok{test}\NormalTok{(input)}
+
+    \ControlFlowTok{case}\NormalTok{ input}
+    \ControlFlowTok{when} \DataTypeTok{Numeric}
+      \FunctionTok{puts} \StringTok{"The input is numeric: }\SpecialCharTok{\#\{}\NormalTok{input}\SpecialCharTok{\}}\StringTok{"}
+    \ControlFlowTok{when} \DataTypeTok{String}
+      \FunctionTok{puts} \StringTok{"The input is a string: }\SpecialCharTok{\#\{}\NormalTok{input}\SpecialCharTok{\}}\StringTok{"}
+    \ControlFlowTok{else}
+      \FunctionTok{puts} \StringTok{"The input is neither a number nor a string"}
+    \ControlFlowTok{end}
+
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+
+\OtherTok{@t} \OperatorTok{=} \DataTypeTok{Test}\AttributeTok{.new}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@t}\AttributeTok{.test}\NormalTok{(}\DecValTok{5}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## The input is numeric: 5
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@t}\AttributeTok{.test}\NormalTok{(}\StringTok{"Hello"}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## The input is a string: Hello
+\end{verbatim}
+
+Ruby has ways of dealing with multiple arguments, missing arguments,
+undefined number of arguments, named arguments, unnamed arguments, etc.
+This is beyond the scope of this document and we suggest the interested
+reader to go to the many resources about Ruby that can easily be found
+on the web.
+
+We will now create a new class `Partition' that we will use later in
+this document. This class will have only the basic methods needed for
+the examples to work.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Partition}
+
+  \OtherTok{attr\_reader} \WarningTok{:nb\_groups}
+  \OtherTok{attr\_reader} \WarningTok{:part}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(nb\_groups, part)}
+    \OtherTok{@nb\_groups} \OperatorTok{=}\NormalTok{ nb\_groups}
+    \OtherTok{@part} \OperatorTok{=}\NormalTok{ part}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+
+\OtherTok{@partCochin} \OperatorTok{=} \DataTypeTok{Partition}\AttributeTok{.new}\NormalTok{(}\DecValTok{2}\NormalTok{, }\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\StringTok{"A"}\NormalTok{,}\StringTok{"B"}\NormalTok{,}\StringTok{"A"}\NormalTok{,}\StringTok{"B"}\NormalTok{)}\AttributeTok{.factor}\NormalTok{)}
+\OtherTok{@partStAnne} \OperatorTok{=} \DataTypeTok{Partition}\AttributeTok{.new}\NormalTok{(}\DecValTok{2}\NormalTok{, }\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\StringTok{"A"}\NormalTok{,}\StringTok{"B"}\NormalTok{)}\AttributeTok{.rep}\NormalTok{(}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{50}\NormalTok{,}\DecValTok{30}\NormalTok{))}\AttributeTok{.factor}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@partCochin}\AttributeTok{.part}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] A B A B
+## Levels: A B
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@partStAnne}\AttributeTok{.part}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##  [1] A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A
+## [34] A A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B
+## [67] B B B B B B B B B B B B B B
+## Levels: A B
+\end{verbatim}
+
+We will suppose that part is always composed of capital letters going
+from A to LETTERS{[}nb\_groups{]}.
+
+\section{Inheritance}\label{inheritance}
+
+Ruby being a powerful Object Oriented language has the concept of
+Inheritance, but it does not allow for multiple inheritance. Multiple
+inheritance has many drawbacks and Ruby just does not support it.
+However, Ruby has other concepts that make up for the lack of multiple
+inheritance as we will see in the following examples.
+
+So, let's go back to SS4 examples. We want now to define a class called
+TrajPartitioned that inherits from class Trajectories. When a class has
+a parent, all methods available for the parent are also available to the
+child.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{TrajPartitioned} \OperatorTok{\textless{}} \DataTypeTok{Trajectories}
+
+  \OtherTok{attr\_reader} \WarningTok{:list\_partitions}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+That's all there is to it! We've just created a class TrajPartitioned
+that inherits all methods from class Trajectories and at this point does
+nothing different from Trajectories, but adds a new instance variable:
+list\_partitions.
+
+Creating TrajPartitioned without arguments will generate an error, since
+a Trajectories requires both times and matrix to be non null.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{begin}
+  \OtherTok{@tdPitie} \OperatorTok{=} \DataTypeTok{TrajPartitioned}\AttributeTok{.new}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF boxes.}
+  \FunctionTok{puts}\NormalTok{ e}\AttributeTok{.class.to\_s}
+  \CommentTok{\# Wrap long messages for PDF code{-}box width.}
+\NormalTok{  e}\AttributeTok{.message.to\_s.scan}\NormalTok{(}\SpecialStringTok{/.\{1,68\}/}\NormalTok{)}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{line}\OperatorTok{|} \FunctionTok{puts}\NormalTok{ line }\OperatorTok{\}}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## RuntimeError
+## Neither times nor matrix can be an empty object
+\end{verbatim}
+
+Let's try to create a TrajPartitioned, but passing to it two partitions.
+For that, let's first create a new Partition:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@partCochin2} \OperatorTok{=} \DataTypeTok{Partition}\AttributeTok{.new}\NormalTok{(}\DecValTok{3}\NormalTok{, }\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\StringTok{"A"}\NormalTok{, }\StringTok{"C"}\NormalTok{, }\StringTok{"C"}\NormalTok{, }\StringTok{"B"}\NormalTok{)}\AttributeTok{.factor}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+And now let's create the TrajPartitioned:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{begin}
+  \OtherTok{@tdCochin} \OperatorTok{=} \DataTypeTok{TrajPartitioned}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{3}\NormalTok{,}\DecValTok{4}\NormalTok{,}\DecValTok{5}\NormalTok{),}
+    \WarningTok{matrix:} \OtherTok{@trajCochin}\AttributeTok{.matrix}\NormalTok{,}
+                                 \WarningTok{list\_partitions:} \ConstantTok{R}\AttributeTok{.list}\NormalTok{(}\OtherTok{@partCochin}\NormalTok{,}
+                                   \OtherTok{@partCochin2}\NormalTok{))}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF boxes.}
+  \FunctionTok{puts}\NormalTok{ e}\AttributeTok{.class.to\_s}
+  \CommentTok{\# Wrap long messages for PDF code{-}box width.}
+\NormalTok{  e}\AttributeTok{.message.to\_s.scan}\NormalTok{(}\SpecialStringTok{/.\{1,68\}/}\NormalTok{)}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{line}\OperatorTok{|} \FunctionTok{puts}\NormalTok{ line }\OperatorTok{\}}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ArgumentError
+## unknown keyword: :list_partitions
+\end{verbatim}
+
+This didn't work: R function `list' expects R objects, and in this case,
+@partCochin and @partCochin2 are Ruby classes, so trying to apply
+function list to them does not work. Clearly, we will have to work in
+the realm of Ruby to keep the list of partitions. This is not a problem
+as Ruby has data structures to maintain a list of objects, the Array.
+Let's then try another solution:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{begin}
+  \OtherTok{@tdCochin} \OperatorTok{=} \DataTypeTok{TrajPartitioned}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{3}\NormalTok{,}\DecValTok{4}\NormalTok{,}\DecValTok{5}\NormalTok{),}
+    \WarningTok{matrix:} \OtherTok{@trajCochin}\AttributeTok{.matrix}\NormalTok{,}
+                                 \WarningTok{list\_partitions:} \KeywordTok{[}\OtherTok{@partCochin}\NormalTok{,}
+                                   \OtherTok{@partCochin2}\KeywordTok{]}\NormalTok{)}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF boxes.}
+  \FunctionTok{puts}\NormalTok{ e}\AttributeTok{.class.to\_s}
+  \CommentTok{\# Wrap long messages for PDF code{-}box width.}
+\NormalTok{  e}\AttributeTok{.message.to\_s.scan}\NormalTok{(}\SpecialStringTok{/.\{1,68\}/}\NormalTok{)}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{line}\OperatorTok{|} \FunctionTok{puts}\NormalTok{ line }\OperatorTok{\}}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ArgumentError
+## unknown keyword: :list_partitions
+\end{verbatim}
+
+We now get a second error: `unknown keyword: list\_partitions'. Class
+TrajPartitioned inherits from class Trajectories and class Trajectories
+has an initialize function that requires two parameters, times and
+matrix; list\_partitions is not a parameter for initialize and is thus
+unknown. In order to fix this problem we need to create an initialize
+method for class TrajPartitioned.
+
+\section{The `super' Keyword}\label{the-super-keyword}
+
+R has a method called `callNextMethod' for control flow between
+inherited classes. In Ruby, we have a model that is a bit different.
+When a method is called on a subclass, if this method is not found it
+will be searched in the parent class and it will go up the hierarchy of
+classes until it is found or an error is issued. If we want the parent
+method to be called we can call `super':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{TrajPartitioned}
+
+  \ControlFlowTok{def}\NormalTok{ initialize(times}\OperatorTok{:} \DecValTok{nil}\NormalTok{, }\WarningTok{matrix:} \DecValTok{nil}\NormalTok{, }\WarningTok{list\_partitions:} \DecValTok{nil}\NormalTok{)}
+    \DecValTok{super}\NormalTok{(}\WarningTok{times:}\NormalTok{ times, }\WarningTok{matrix:}\NormalTok{ matrix)}
+    \OtherTok{@list\_partitions} \OperatorTok{=}\NormalTok{ list\_partitions}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+Let's try our example again:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@tdCochin} \OperatorTok{=} \DataTypeTok{TrajPartitioned}\AttributeTok{.new}\NormalTok{(}\WarningTok{times:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{,}\DecValTok{3}\NormalTok{,}\DecValTok{4}\NormalTok{,}\DecValTok{5}\NormalTok{),}
+  \WarningTok{matrix:} \OtherTok{@trajCochin}\AttributeTok{.matrix}\NormalTok{,}
+                               \WarningTok{list\_partitions:} \KeywordTok{[}\OtherTok{@partCochin}\NormalTok{,}
+                                 \OtherTok{@partCochin2}\KeywordTok{]}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~~~ Trajectories: inspector ~~~ 
+## ~~~ Trajectories: initializator ~~~ 
+## *** Class Trajectories, method Show *** 
+## times = 1
+## 3
+## 4
+## 5
+## * Traj (limited to a matrix 10x10) = 
+##    T1      T3      T4      T5     
+## I1 "15.00" "15.10" "15.20" "15.20"
+## I2 "16.00" "15.90" "16.00" "16.40"
+## I3 "15.20" "   NA" "15.30" "15.30"
+## I4 "15.70" "15.60" "15.80" "16.00"
+## ******* End Show (trajectories) *******
+\end{verbatim}
+
+Now @tdCochin is created correctly; however, the `show' method only
+shows information about times and matrix, there is nothing about our new
+list\_partitions variable. This is so, since there is no method `show'
+in TrajPartitioned, so method `show' from Trajectories is executed.
+
+So, let's start by writing a `print' method, that will print all the
+information we have in TrajPartitioned. The flow of control for this
+method is: Ruby sees a call to `print', so it checks to see if `print'
+is a method for TrajPartitioned. Since we have just defined this method,
+Ruby finds it and executes it. The first command in print is a call to
+`super', which will call the parent `print' method, that prints
+information for `times' and `matrix'. When the parent `print' finishes
+control continues after the `super' call, printing the number of
+available partitions.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{TrajPartitioned}
+
+  \ControlFlowTok{def} \FunctionTok{print}
+    \DecValTok{super}
+    \FunctionTok{puts}\NormalTok{(}
+      \StringTok{"the object also contains "} \OperatorTok{+}
+      \StringTok{"}\SpecialCharTok{\#\{}\OtherTok{@list\_partitions}\AttributeTok{.length}\SpecialCharTok{\}}\StringTok{ partition"}\NormalTok{)}
+    \FunctionTok{puts}\NormalTok{ (}\StringTok{"***** Fine of print (TrajPartitioned) *****"}\NormalTok{)}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@tdCochin}\AttributeTok{.print}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## *** Class Trajectories, method Print *** 
+## times = 1
+## 3
+## 4
+## 5
+## traj =
+##      T1   T3   T4   T5
+## I1 15.0 15.1 15.2 15.2
+## I2 16.0 15.9 16.0 16.4
+## I3 15.2   NA 15.3 15.3
+## I4 15.7 15.6 15.8 16.0
+## ******* End Print (trajectories) ******* 
+## the object also contains 2 partition
+## ***** Fine of print (TrajPartitioned) *****
+\end{verbatim}
+
+Notice that this model is much cleaner than `callNextMethod' and is not
+subject to any of the difficulties presented in SS4 and there is no need
+for the keywords ``is'', ``as'' and ``as\textless-'', although Ruby
+provides methods to check the class of an object, its hierarchy, etc.
+when needed.
+
+In Ruby there is no similar method as ``setIs'' and it is not possible
+to convert one class into another, but there are other ways of getting
+the necessary results. Let's then implement a method that returns the
+partition with the least number of groups. First, as usual, the R code
+with `setIs':
+
+\begin{verbatim}
+> setIs(
++ class1="TrajPartitioned",
++ class2="Partition",
++ coerce=function(from,to){
++ numberGroups <- sapply(tdCochin@listPartitions,getNbGroups)
++ Smallest <- which.min(-numberGroups)
++ to<-new("Partition")
++ to@nbGroups <- getNbGroups(from@listPartitions[[Smallest]])
++ to@part <- getPart(from@listPartitions[[Smallest]])
++ return(to)
++ }
++ )
+\end{verbatim}
+
+And now the Ruby code. Here we are getting deeper into Ruby and it is
+becoming harder for a pure R developer to understand the code. We will
+describe it in more detail:
+
+\begin{itemize}
+\item
+  We define a method called `to\_part' that has one argument `which'. By
+  default `which' is `:min', the name of the minimum method. This means
+  that if no argument is given to to\_part it will assume which = :min;
+\item
+  @list\_partitions is a Ruby array. Method map is similar to method
+  sapply in R, it applies a `block' to every element of the array,
+  returning an array. Describing blocks is beyond the scope of this
+  document, but we can think of it as if it were a function. The block
+  is in `\{\}' and has one argument named `part'. Thus, map goes through
+  all elements of the array, and gets the nb\_groups of the element and
+  returns them into the number\_groups array.
+\item
+  number\_groups is an array and doing number\_groups.min returns the
+  minimum value in number\_groups and number\_groups.max the maximum. We
+  can call a method on an object by `sending' the method name to the
+  object, so, number\_groups.send(:min) is equivalent to
+  number\_groups.min;
+\item
+  Method `index' for array, returns the index of a given element. So,
+  number\_groups.index(3) would return the index of the element `3'.
+  Then number\_groups.index(number\_groups.min) returns the index of the
+  minimum element in the array. This is the equivalent of R
+  which.min(number\_groups);
+\item
+  Finally, number\_groups.index(number\_groups.send(which)), will return
+  the index of the element we ask for, be it :min or :max. Note that if
+  we pass another value, this would be an error.
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{TrajPartitioned}
+
+  \ControlFlowTok{def}\NormalTok{ to\_part(which }\OperatorTok{=} \WarningTok{:min}\NormalTok{)}
+\NormalTok{    number\_groups }\OperatorTok{=} \OtherTok{@list\_partitions}\AttributeTok{.map} \OperatorTok{\{} \OperatorTok{|}\NormalTok{part}\OperatorTok{|}\NormalTok{ part}\AttributeTok{.nb\_groups} \OperatorTok{\}}
+\NormalTok{    selected }\OperatorTok{=}\NormalTok{ number\_groups}\AttributeTok{.index}\NormalTok{(number\_groups}\AttributeTok{.send}\NormalTok{(which))}
+    \ControlFlowTok{return} \OtherTok{@list\_partitions}\KeywordTok{[}\NormalTok{selected}\KeywordTok{]}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+To get the partition with the minimum number of elements:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@tdCochin}\AttributeTok{.to\_part.part}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] A B A B
+## Levels: A B
+\end{verbatim}
+
+To get the partition with the maximum number of elements:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@tdCochin}\AttributeTok{.to\_part}\NormalTok{(}\WarningTok{:max}\NormalTok{)}\AttributeTok{.part}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] A C C B
+## Levels: A B C
+\end{verbatim}
+
+In this example we did not follow exactly the R code from SS4. The
+reason for that is that `list\_partitions' is a list of Ruby classes and
+we cannot run sapply on this list. If we try to call a `getNbGroups' or
+in the Ruby case nb\_groups via R's sapply, the code will crash.
+
+\section{Virtual Classes}\label{virtual-classes}
+
+In Ruby there are no ``Virtual Classes'', but it is possible to
+implement derived classes from a parent class with methods that behave
+properly according to the object's class. Following SS4 we will
+implement two classes: PartitionSimple and PartitionEval which are
+subclasses of class PartitionFather. PartitionFather will just be a
+regular class. Methods defined in PartitionFather will be available to
+be used in the subclasses
+
+Here is the R code of those classes and the implementation of a method
+in PartitionFather that multiplies the number of groups by 2:
+
+\begin{verbatim}
+> setClass(
++ Class="PartitionFather",
++ representation=representation(nbGroups="numeric","VIRTUAL")
++ )
+
+> setClass(
++ Class="PartitionSimple",
++ representation=representation(part="factor"),
++ contains="PartitionFather"
++ )
+
+> setClass(
++ Class="PartitionEval",
++ representation=representation(part="ordered"),
++ contains="PartitionFather"
++ )
+
+> setGeneric("nbMultTwo",function(object){standardGeneric("nbMultTwo")})
+
+> setMethod("nbMultTwo","PartitionFather",
++ function(object){
++ object@nbGroups <- object@nbGroups*2
++ return (object)
++ }
++ )
+\end{verbatim}
+
+Since Ruby has no type definition, there is no really need for a parent
+class and subclasses. However, we will implement those classes in order
+to show Ruby's inheritance:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{\# Parent class.  Differently from SS4, both \textquotesingle{}nb\_groups\textquotesingle{} and \textquotesingle{}part\textquotesingle{} are}
+\CommentTok{\# defined in the}
+\CommentTok{\# parent class.}
+\ControlFlowTok{class} \DataTypeTok{PartitionFather}
+
+  \OtherTok{attr\_reader} \WarningTok{:nb\_groups}
+  \OtherTok{attr\_reader} \WarningTok{:part}
+
+  \CommentTok{\# initialize class PartitionFather with the number of groups and}
+  \CommentTok{\# parts.  Note that we}
+  \CommentTok{\# use R.c for nb\_groups in order to convert the number of groups into}
+  \CommentTok{\# an R vector.}
+  \ControlFlowTok{def}\NormalTok{ initialize(nb\_groups}\OperatorTok{:} \DecValTok{0}\NormalTok{, }\WarningTok{part:} \DecValTok{nil}\NormalTok{)}
+    \OtherTok{@nb\_groups} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(nb\_groups)}
+    \OtherTok{@part} \OperatorTok{=}\NormalTok{ part}
+  \ControlFlowTok{end}
+
+  \CommentTok{\# method nb\_mult\_two can be called from all subclasses}
+  \ControlFlowTok{def}\NormalTok{ nb\_mult\_two}
+    \OtherTok{@nb\_groups} \OperatorTok{*} \DecValTok{2}
+  \ControlFlowTok{end}
+
+  \CommentTok{\# method \textquotesingle{}to\_s\textquotesingle{} is called whenever we try to print a Ruby object.}
+  \CommentTok{\# This method emulates}
+  \CommentTok{\# R \textquotesingle{}print\textquotesingle{} method that prints all the slots.}
+  \ControlFlowTok{def}\NormalTok{ to\_s}
+    \FunctionTok{puts}\NormalTok{ (}\StringTok{"Variable \textquotesingle{}nb\_groups\textquotesingle{}:"}\NormalTok{)}
+    \FunctionTok{puts} \OtherTok{@nb\_groups}
+    \FunctionTok{puts}
+    \FunctionTok{puts}\NormalTok{ (}\StringTok{"Variable \textquotesingle{}part\textquotesingle{}:"}\NormalTok{)}
+    \FunctionTok{puts} \OtherTok{@part}
+    \FunctionTok{puts}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+
+\CommentTok{\# Class PartitionSimple is a subclass of PartitionFather.  To make a}
+\CommentTok{\# subclass of a}
+\CommentTok{\# class we use the operator \textquotesingle{}\textless{}\textquotesingle{}.  Since the whole logic is in the parent}
+\CommentTok{\# class}
+\CommentTok{\# PartitionSimple is just an empty class}
+\ControlFlowTok{class} \DataTypeTok{PartitionSimple} \OperatorTok{\textless{}} \DataTypeTok{PartitionFather}
+
+\ControlFlowTok{end}
+
+\CommentTok{\# PartitionEval is also only an empty class}
+\ControlFlowTok{class} \DataTypeTok{PartitionEval} \OperatorTok{\textless{}} \DataTypeTok{PartitionFather}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@a} \OperatorTok{=} \DataTypeTok{PartitionSimple}\AttributeTok{.new}\NormalTok{(}
+  \WarningTok{nb\_groups:} \DecValTok{3}\NormalTok{,}
+  \WarningTok{part:}\NormalTok{ ((}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:LETTERS}\KeywordTok{]}\NormalTok{)}\KeywordTok{[}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{)}\KeywordTok{]}\AttributeTok{.factor}\NormalTok{))}
+\FunctionTok{puts} \OtherTok{@a}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Variable 'nb_groups':
+## 3
+## 
+## Variable 'part':
+## [1] A B C B B A
+## Levels: A B C
+## 
+## #<RC::PartitionSimple:0x5f44865c>
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@a}\AttributeTok{.nb\_mult\_two}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 6
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@b} \OperatorTok{=} \DataTypeTok{PartitionEval}\AttributeTok{.new}\NormalTok{(}
+  \WarningTok{nb\_groups:} \DecValTok{5}\NormalTok{,}
+  \WarningTok{part:}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:LETTERS}\KeywordTok{]}\NormalTok{)}\KeywordTok{[}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{4}\NormalTok{)}\KeywordTok{]}\AttributeTok{.ordered}\NormalTok{)}
+\FunctionTok{puts} \OtherTok{@b}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Variable 'nb_groups':
+## 5
+## 
+## Variable 'part':
+## [1] A E C D B D
+## Levels: A < B < C < D < E
+## 
+## #<RC::PartitionEval:0x45e699f1>
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@b}\AttributeTok{.nb\_mult\_two}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 10
+\end{verbatim}
+
+The example above, although it replicates SS4 is not actually very
+useful from the point of view of class hierarchy in Ruby. We will then
+write a new function to\_s in class PartitionSimple that will print the
+name of the class:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{PartitionSimple}
+
+  \ControlFlowTok{def}\NormalTok{ to\_s}
+    \FunctionTok{puts}\NormalTok{(}\StringTok{"Class PartitionSimple"}\NormalTok{)}
+    \DecValTok{super}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@a}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Class PartitionSimple
+## Variable 'nb_groups':
+## 3
+## 
+## Variable 'part':
+## [1] A B C B B A
+## Levels: A B C
+## 
+## #<RC::PartitionSimple:0x5f44865c>
+\end{verbatim}
+
+As can be seen, `puts @a' now calls method `to\_s' defined in class
+PartitionSimple. This method prints `Class PartitionSimple' and then
+calls the super method, i.e., method `to\_s' from class PartitionFather.
+
+Note though that `puts @b' still prints the same output, since it has no
+particular `to\_s' method.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \OtherTok{@b}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Variable 'nb_groups':
+## 5
+## 
+## Variable 'part':
+## [1] A E C D B D
+## Levels: A < B < C < D < E
+## 
+## #<RC::PartitionEval:0x45e699f1>
+\end{verbatim}
+
+\section{Internal Modification of an
+Object}\label{internal-modification-of-an-object}
+
+\subsection{Method to Modify a Field}\label{method-to-modify-a-field}
+
+Let us return to our trajectories example and define a third method that
+imputes data for missing values. To simplify, we will impute by
+replacing by the mean values. This is the R code to do this:
+
+\begin{verbatim}
+> meanWithoutNa <- function (x){mean(x,na.rm=TRUE)}
+> setGeneric("impute",function (.Object){standardGeneric("impute")})
+> setMethod(
++ f="impute",
++ signature="Trajectories",
++ def=function(.Object){
++ average <- apply(.Object@traj,2,meanWithoutNa)
++ for (iCol in 1:ncol(.Object@traj)){
++ .Object@traj[is.na(.Object@traj[,iCol]),iCol] <- average[iCol]
++ }
++ return(.Object)
++ }
++ )
+\end{verbatim}
+
+The code above, as explained in SS4 creates a new object and does not
+change the original one. So, calling impute(trajCochin) will work
+correctly by creating a new object but will not change trajCochin. This
+works fine, but can be memory expensive if the matrix is a large one.
+
+Let's now implement the same method in Galaaz 2.0. We stay on the R side
+of the bridge: for each column, compute the mean with
+\texttt{na.rm\ =\ true}, then replace NA entries with that mean (via
+\texttt{R.ifelse} / \texttt{is\_\_na}), and rebuild the matrix with
+\texttt{R.cbind}. No MDArray iteration is required.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{class} \DataTypeTok{Trajectories}
+
+  \ControlFlowTok{def}\NormalTok{ impute}
+\NormalTok{    ncols }\OperatorTok{=} \OtherTok{@matrix}\AttributeTok{.ncol} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}
+\NormalTok{    imputed }\OperatorTok{=}\NormalTok{ (}\DecValTok{1}\OperatorTok{..}\NormalTok{ncols)}\AttributeTok{.map} \ControlFlowTok{do} \OperatorTok{|}\NormalTok{j}\OperatorTok{|}
+\NormalTok{      col }\OperatorTok{=} \OtherTok{@matrix}\KeywordTok{[}\DecValTok{nil}\NormalTok{, j}\KeywordTok{]}
+\NormalTok{      avg }\OperatorTok{=}\NormalTok{ col}\AttributeTok{.mean}\NormalTok{(}\WarningTok{na\_\_rm:} \DecValTok{true}\NormalTok{)}
+      \ConstantTok{R}\AttributeTok{.ifelse}\NormalTok{(col}\AttributeTok{.is\_\_na}\NormalTok{, avg, col)}
+    \ControlFlowTok{end}
+\NormalTok{    col\_names }\OperatorTok{=} \OtherTok{@matrix}\AttributeTok{.colnames}
+\NormalTok{    row\_names }\OperatorTok{=} \OtherTok{@matrix}\AttributeTok{.rownames}
+    \OtherTok{@matrix} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.cbind}\NormalTok{(}\OperatorTok{*}\NormalTok{imputed)}
+    \OtherTok{@matrix}\AttributeTok{.colnames} \OperatorTok{=}\NormalTok{ col\_names }\ControlFlowTok{unless}\NormalTok{ col\_names}\AttributeTok{.nil?}
+    \OtherTok{@matrix}\AttributeTok{.rownames} \OperatorTok{=}\NormalTok{ row\_names }\ControlFlowTok{unless}\NormalTok{ row\_names}\AttributeTok{.nil?}
+    \DecValTok{self}
+  \ControlFlowTok{end}
+
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\OtherTok{@trajCochin}\AttributeTok{.impute}
+\FunctionTok{puts} \OtherTok{@trajCochin}\AttributeTok{.matrix}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## $rownames
+## [1] "I1" "I2" "I3" "I4"
+\end{verbatim}
+
+It works, and \texttt{@trajCochin.matrix} was updated. Under GNU R,
+assignment follows R's usual copy-on-write semantics: replacing
+\texttt{@matrix} (or assigning into an R object through the bridge)
+binds a new vector/matrix rather than mutating a shared MDArray store.
+That is a deliberate difference from the Renjin/MDArray mutation
+experiments in the older paper; those demos are not part of Galaaz 2.0.
+
+\section{Conclusions I}\label{conclusions-i}
+
+This ends the SS4 paper material for classes and inheritance. We believe
+we have shown that R S4 can be substituted by Galaaz and Ruby classes
+and that Galaaz makes an easy transition from R developers to Ruby. Ruby
+is a very flexible and powerful language and has many interesting
+libraries, where Rails is maybe one of the best known, but there are
+thousands of others. For those interested in getting deeper into Ruby's
+libraries, we suggest they look at:
+
+\begin{itemize}
+\tightlist
+\item
+  \url{https://github.com/markets/awesome-ruby}
+\item
+  \url{http://bestgems.org/}
+\end{itemize}
+
+For those interested in Ruby and science, we recommend:
+
+\begin{itemize}
+\tightlist
+\item
+  \url{http://sciruby.com/}
+\end{itemize}
+
+\textbf{Galaaz 2.0} runs on \textbf{JRuby or CRuby} and talks to
+\textbf{GNU R} through the bridge described in this series --- the same
+integration model used throughout the examples above.
+
+\section{Callbacks and R calling into
+Ruby}\label{callbacks-and-r-calling-into-ruby}
+
+On this paper we have focused on accessing R functions from Ruby and
+have shown how to integrate Ruby with R from the point of view of a Ruby
+developer. The complementary direction --- R calling back into Ruby ---
+is also supported in Galaaz 2.0.
+
+Galaaz 2.0 uses the \textbf{bridge callback} mechanism: Ruby procs (and
+related callables) can be passed where R expects functions, so
+algorithms written in R (for example optimizers or higher-order
+\texttt{*apply} helpers) can invoke Ruby logic without leaving the
+bridge session. Details, options such as callback timeouts, and further
+examples are in the project manual and on the documentation site:
+\url{https://rbotafogo.github.io/galaaz/}.
+
+We do not reproduce here the older Renjin-era material on packing Ruby
+objects as R external pointers, constructing Ruby classes from R via JVM
+APIs, or calling Java collections from R scripts. Those sections
+belonged to a different runtime; the callback bridge is the supported
+path in Galaaz 2.0.
+
+\section{Conclusions II}\label{conclusions-ii}
+
+\textbf{JRuby or CRuby + GNU R + Galaaz} gives a practical polyglot
+stack: idiomatic Ruby for structure and libraries, GNU R for statistics
+and the CRAN/Bioconductor ecosystem, and Galaaz as the bridge between
+them. As always, choose the right tools for the job at hand --- and when
+the job sits between an R-only workflow and a broader polyglot
+application, Galaaz is designed to connect those worlds.
+
 \end{document}