galaaz 0.4.9 → 0.4.10

data/blogs/ruby_plot/ruby_plot.md

@@ -121,10 +121,7 @@ Ruby and dozens of other languages.  Yet, while R and Python chunks can share da
 languages, chunks are independent.  This means that a variable defined in one chunk
 cannot be used in another chunk.
 
-With _gKnit_ Ruby code chunks can share data.  In gKnit each
-Ruby chunk executes in its own scope and thus, local variable defined in a chunk are
-not accessible by other chunks.  Yet, All chunks execute in the scope of a 'chunk'
-class and instance variables ('@'), are available in all chunks.
+With _gKnit_ Ruby code chunks can share data.
 
 # Exploring the Dataset
 
@@ -139,17 +136,17 @@ in 60 guinea pigs, where each animal received one of three dose levels of Vitami
 The ToothGrowth dataset contains three columns: 'len', 'supp' and 'dose'.  Let's
 take a look at a few rows of this dataset. In Galaaz, R variables are accessed
 by using the corresponding Ruby symbol preceeded by the tilda ('~') function. Note in the
-following chunk that 'ToothGrowth' is the R  variable and Ruby's '@tooth_growth' is
+following chunk that 'ToothGrowth' is the R  variable and Ruby's 'tooth_growth' is
 assigned the value of '~:ToothGrowth'.
 
 
 ```ruby
 # Read the R ToothGrowth variable and assign it to the
-# Ruby instance variable @tooth_growth that will be 
+# Ruby instance variable tooth_growth that will be 
 # available to all Ruby chunks in this document.
-@tooth_growth = ~:ToothGrowth
+tooth_growth = ~:ToothGrowth
 # print the first few elements of the dataset
-puts @tooth_growth.head
+puts tooth_growth.head
 ```
 
 ```
@@ -171,7 +168,7 @@ in usual Ruby style.
 ```ruby
 # Access the tooth_growth 'len' column and print the first few
 # elements of this column with the 'head' method.
-puts @tooth_growth.len.head
+puts tooth_growth.len.head
 ```
 
 ```
@@ -188,7 +185,7 @@ The function 'as.factor' becomes 'R.as__factor' or just 'as__factor' when chaini
 
 ```ruby
 # convert the dose to a factor
-@tooth_growth.dose = @tooth_growth.dose.as__factor
+tooth_growth.dose = tooth_growth.dose.as__factor
 ```
 
 Let's explore some more details of this dataset.  In particular, let's look at its dimensions,
@@ -196,7 +193,7 @@ structure and summary statistics.
 
 
 ```ruby
-puts @tooth_growth.dim
+puts tooth_growth.dim
 ```
 
 ```
@@ -211,7 +208,7 @@ as a side effect.
 
 
 ```ruby
-@tooth_growth.str
+tooth_growth.str
 ```
 
 ```
@@ -227,7 +224,7 @@ Finally, using the summary method, we get the statistical summary for the datase
 
 
 ```ruby
-puts @tooth_growth.summary
+puts tooth_growth.summary
 ```
 
 ```
@@ -259,36 +256,23 @@ to form the final graphics.
 
 In order to make a plot, we use the 'ggplot' function to the dataset.  In R, this would be
 written as ```ggplot(<dataset>, ...)```. Galaaz gives you the flexibility to use
-either ```R.ggplot(<dataset>, ...)``` or ```<dataset>.ggplot(...)```.  In the graph s
-pecification bellow, we use the second notation
-that looks more like Ruby.  ggplot uses the ‘aes’ method to specify
+either ```R.ggplot(<dataset>, ...)``` or ```<dataset>.ggplot(...)```.  In the graph 
+specification bellow, we use the second notation that looks more like Ruby.  
+ggplot uses the ‘aes’ method to specify
 x and y axes; in this case, the 'dose' on the $x$ axis and the 'length' on
 the $y$ axis: 'E.aes(x: :dose, y: :len)'.  To specify the type of plot add a geom to
 the plot.  For a boxplot, the geom is R.geom_boxplot.
 
-Note also that we have a call to 'R.png' before plotting and 'R.dev__off' after the print
-statement.  'R.png' opens a 'png device' for outputting the plot.  If we do no pass a
-name to the 'png' function, the
-image gets a default name of 'Rplot\<nnn\>' where \<nnn\> is the number of the plot.
-'R.dev__off'
-closes the device and creates the 'png' file. We can
-then include the generated 'png' file in the document by adding an rmarkdown directive.
-
 
 ```ruby
 require 'ggplot'
 
-e = @tooth_growth.ggplot(E.aes(x: :dose, y: :len))
+e = tooth_growth.ggplot(E.aes(x: :dose, y: :len))
 print e + R.geom_boxplot
 ```
 
 ![](/home/rbotafogo/desenv/galaaz/blogs/ruby_plot/ruby_plot_files/figure-html/dose_len.png)<!-- -->
 
-[//]: # (Including the 'png' file generated above.  In future releases)
-[//]: # (of gKnit, the figures should be automatically saved and the name)
-[//]: # (taken from the chunk 'label' and possibly chunk parameters)
-
-
 Great! We've just managed to create and save our first plot in Ruby with only
 four lines of code. We can now easily see with this plot a clear trend: as the
 dose of the supplement
@@ -308,32 +292,28 @@ automatically creates the facets based on the delivery method factors.  The para
 the 'facet_grid' method is a [_formula_](https://thomasleeper.com/Rcourse/Tutorials/formulae.html).
 
 In Galaaz we give programmers the flexibility to use two different ways to write formulas.
-In the first way, the following changes from writing formulas (for example 'x ~ y')
-in R are necessary:
+In the first way, we use Ruby expressions and the '.til' function. The formula 'x ~ y', becomes
+':x.til :y'. More information on expressions can be found in [Galaaz Manual](https://www.rubydoc.info/gems/galaaz/).
 
-* R symbols are represented by the same Ruby symbol prefixed with the '+' method. The
-  symbol ```x``` in R becomes ```+:x``` in Ruby;
-* The '~' operator in R becomes '=~' in Ruby.  The formula ```x ~ y``` in R is written as
-  ```+:x =~ +:y``` in Ruby;
-* The '.' symbol in R becomes '+:all'
 
 Another way of writing a formula is to use the 'formula' function with the actual formula as
 a string.  The formula ```x ~ y``` in R can be written as ```R.formula("x ~ y")```.  For more
 complex formulas, the use of the 'formula' function is preferred.
 
-The formula ```+:all =~ +:supp``` indicates to the 'facet_grid' function that it needs to
+The formula ```:all.til :supp``` indicates to the 'facet_grid' function that it needs to
 facet the plot based on the ```supp``` variable and split the plot vertically.  Changing
-the formula to ```+:supp =~ +:all``` would split the plot horizontally.
+the formula to ```:supp.til :all``` would split the plot horizontally.
 
 
 ```ruby
-@base_tooth = @tooth_growth.ggplot(E.aes(x: :dose, y: :len, group: :dose))
 
-@bp = @base_tooth + R.geom_boxplot +
+base_tooth = tooth_growth.ggplot(E.aes(x: :dose, y: :len, group: :dose))
+
+bp = base_tooth + R.geom_boxplot +
       # Split in vertical direction
       R.facet_grid(:all.til :supp)
       
-puts @bp
+puts bp
 ```
 
 
@@ -355,8 +335,8 @@ factor gets its own color.
 
 
 ```ruby
-@bp = @bp + R.geom_boxplot(E.aes(fill: :dose))
-puts @bp
+bp = bp + R.geom_boxplot(E.aes(fill: :dose))
+puts bp
 ```
 
 
@@ -394,9 +374,9 @@ plot.
 
 ```ruby
 # Split in vertical direction
-@bp = @bp + R.geom_point
+bp = bp + R.geom_point
 
-puts @bp
+puts bp
 ```
 
 
@@ -416,7 +396,7 @@ color and change the shape of the points, making them even easier to see.
 
 ```ruby
 # Split in vertical direction
-puts @bp + R.geom_jitter(shape: 23, color: "cyan3", size: 1)
+puts bp + R.geom_jitter(shape: 23, color: "cyan3", size: 1)
 ```
 
 
@@ -457,11 +437,11 @@ matches with the actual order of the colors in the plot.
 
 
 ```ruby
-@bp = @bp +
-      R.scale_fill_manual(values: R.c("cyan", "deepskyblue", "deepskyblue4"),
+bp = bp +
+     R.scale_fill_manual(values: R.c("cyan", "deepskyblue", "deepskyblue4"),
                           breaks: R.c("2","1","0.5"))
 
-puts @bp
+puts bp
 ```
 
 
@@ -486,13 +466,13 @@ a boxplot known as a _violin plot_ with jittered data.
 
 
 ```ruby
-@violin = @base_tooth + R.geom_violin(E.aes(fill: :dose)) + 
+violin = base_tooth + R.geom_violin(E.aes(fill: :dose)) + 
    R.facet_grid(:all.til :supp) +
    R.geom_jitter(shape: 23, color: "cyan3", size: 1) +
    R.scale_fill_manual(values: R.c("cyan", "deepskyblue", "deepskyblue4"),
                        breaks: R.c("2","1","0.5"))
 
-puts @violin
+puts violin
 ```
 
 
@@ -523,13 +503,13 @@ Length of odontoblasts in 60 guinea pigs.
 Each animal received one of three dose levels of vitamin C.
 EOT
 
-@decorations =
+decorations =
   R.labs(title: "Tooth Growth:  Length vs Vitamin C Dose",
          subtitle: "Faceted by delivery method, OJ or VC",
          x: "Dose (mg)", y: "Teeth length",
          caption: caption)
 
-puts @bp + @decorations
+puts bp + decorations
 ```
 
 
@@ -609,14 +589,14 @@ We can now easily make our final boxplot and violin plot.  All the layers for th
 added in order to expose our understanding of the data and the need to present the result
 to our audience.
 
-The final specification is just the addition of all layers build up to this point (@bp), plus
-the decorations (@decorations), plus the corporate theme.
+The final specification is just the addition of all layers build up to this point ('bp'), plus
+the decorations ('decorations'), plus the corporate theme.
 
 Here is our final boxplot, without jitter.
 
 
 ```ruby
-puts @bp + @decorations + CorpTheme.global_theme(faceted: true)
+puts bp + decorations + CorpTheme.global_theme(faceted: true)
 ```
 
 
@@ -627,7 +607,7 @@ boxplot.
 
 
 ```ruby
-puts @violin + @decorations + CorpTheme.global_theme(faceted: true)
+puts violin + decorations + CorpTheme.global_theme(faceted: true)
 ```
 
 
@@ -646,15 +626,16 @@ Length of odontoblasts in 60 guinea pigs.
 Each animal received one of three dose levels of vitamin C.
 EOT
 
-@bp = @tooth_growth.ggplot(E.aes(x: :supp, y: :len, group: :supp)) + 
-      R.geom_boxplot(E.aes(fill: :supp)) + R.facet_grid(:all.til :dose) +
-      R.scale_fill_manual(values: R.c("cyan", "deepskyblue4")) +
-      R.labs(title: "Tooth Growth:  Length by Dose",
-             subtitle: "Faceted by dose",
-             x: "Delivery method", y: "Teeth length",
-             caption: caption) +
-      CorpTheme.global_theme(faceted: true)
-puts @bp
+bp = tooth_growth.ggplot(E.aes(x: :supp, y: :len, group: :supp)) + 
+     R.geom_boxplot(E.aes(fill: :supp)) + R.facet_grid(:all.til :dose) +
+     R.scale_fill_manual(values: R.c("cyan", "deepskyblue4")) +
+     R.labs(title: "Tooth Growth:  Length by Dose",
+            subtitle: "Faceted by dose",
+            x: "Delivery method", y: "Teeth length",
+            caption: caption) +
+     CorpTheme.global_theme(faceted: true)
+
+puts bp
 ```
 
 

data/lib/R_interface/rdata_frame.rb

@@ -97,18 +97,6 @@ module R
       
     end
 
-#=begin    
-    #--------------------------------------------------------------------------------------
-    # @TODO Need to understand why to_ary is being called here and what the effect is of
-    # returning the empty array.  For now, doing this returns better error messages in
-    # rspec
-    #--------------------------------------------------------------------------------------
-
-    def to_ary
-      []
-    end
-#=end
-
   end
   
 end

data/lib/R_interface/robject.rb

@@ -65,16 +65,6 @@ module R
       R::Support.exec_function_name("`==`", @r_interop,
                                     R::Support.parse_arg(other_object))
     end
-
-    #--------------------------------------------------------------------------------------
-    # @TODO: rspec sometimes calls to_ary when an expected value is false.  I still don't
-    # understand this call.  Returning an array with a number inside seems to make
-    # rspec happy, however this could have other consequences I don't know of. 
-    #--------------------------------------------------------------------------------------
-
-    def to_ary
-      [1]
-    end
     
     #--------------------------------------------------------------------------------------
     # @param r_interop [Interop] pointer to an R object
@@ -133,18 +123,28 @@ module R
       end
 
     end
-    
+
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     def method_missing(symbol, *args, &block)
       name = R::Support.convert_symbol2r(symbol)
-=begin
+
       # Need to raise a NoMethodError when method_missing is called by an implicit
-      # call to "to_ary".  I'm not sure why "to_ary" is being called, but it is
+      # call to "to_ary".  The explanation for that is:
+      # Okay, I've found the source of the behaviour. IOOperations.puts will attempt to
+      # coerce an argument to an array and print its contents, and R::Vector responds to
+      # to_ary but returns the empty array which results in no output.
+      #
+      # Previously IOOperations.puts only checked the type of the argument, and did not
+      # attempt coercion, but that meant we didn't match MRI's behaviour and had some test
+      # failures in other gems. I'd suggest either removing the to_ary methods on
+      # R::Object and R::Vector or implementing them more fully. I see from the comments on
+      # those methods that you needed them for RSpec, it might worth seeing if those problems
+      # still occur and we can look a better way to resolve those.      
       raise NoMethodError if name == "to_ary"
-=end      
+
       case
       when block_given?
         R::Support.new_scope(symbol, self, *args, &block)

data/lib/R_interface/ruby_extensions.rb

@@ -21,17 +21,6 @@
 # OR MODIFICATIONS.
 ##########################################################################################
 
-#=begin
-module Kernel
-
-  def puts(*args)
-    print(*args)
-    print "\n"
-  end
-
-end
-#=end
-
 #==========================================================================================
 #
 #==========================================================================================
@@ -173,29 +162,12 @@ class Symbol
     exec_bin_oper("`=`", expression)
   end
   
-=begin
-  #--------------------------------------------------------------------------------------
-  #
-  #--------------------------------------------------------------------------------------
-
-  def [](index)
-    exec_bin_oper("`[[`", index)
-  end
-=end
   #--------------------------------------------------------------------------------------
   #
   #--------------------------------------------------------------------------------------
 
   def method_missing(symbol, *args, &block)
 
-=begin    
-    if (symbol =~ /(.*)=$/)
-      # method_missing_assign($1, args[0])
-    elsif (args.length == 0 && ((R.c(symbol.to_s)._ :in, R.names(self)) >> 0))
-      return self[symbol.to_s]
-    end
-=end
-    
     E.send(symbol.to_s, self, *args)
     
   end
@@ -217,7 +189,7 @@ class Symbol
   def inter(var2)
     R::Support.exec_function(R::Support.range, self, var2)
   end
-
+  
   #--------------------------------------------------------------------------------------
   # If method_missing is implemented, then we also need to implement method 'to_ary'.
   # This is because starting from ruby 1.9 the code for Array#flatten has changed,
@@ -228,7 +200,7 @@ class Symbol
   #--------------------------------------------------------------------------------------
 
   def to_ary
-    [self.to_s]
+    # [self.to_s]
   end
-  
+
 end