galaaz 0.4.5 → 0.4.6

data/examples/sthda_ggplot/two_variables_disc_cont/geom_dotplot.rb

@@ -24,6 +24,8 @@
 require 'galaaz'
 require 'ggplot'
 
+R.install_and_loads('Hmisc')
+
 tooth_growth = ~:ToothGrowth
 tooth_growth.dose = tooth_growth.dose.as__factor
 puts tooth_growth
@@ -39,11 +41,9 @@ sleep(2)
 R.grid__newpage
 
 # Dot plot with mean points (+/- SD)
-# stat_summary requires library Hmisc that does not yet install in
-# graalvm
-# print e + R.geom_dotplot(binaxis: "y", stackdir: "center") + 
-#      R.stat_summary(fun__data: "mean_sdl",  fun__args: E.list(mult: 1), 
-#                     geom: "pointrange", color: "red")
+print e + R.geom_dotplot(binaxis: "y", stackdir: "center") + 
+      R.stat_summary(fun__data: "mean_sdl",  fun__args: E.list(mult: 1), 
+                     geom: "pointrange", color: "red")
 
 sleep(2)
 R.grid__newpage

data/examples/sthda_ggplot/two_variables_disc_cont/geom_jitter.rb

@@ -23,6 +23,7 @@
 
 require 'galaaz'
 require 'ggplot'
+R.install_and_loads('Hmisc')
 
 tooth_growth = ~:ToothGrowth
 tooth_growth.dose = tooth_growth.dose.as__factor

data/examples/sthda_ggplot/two_variables_disc_cont/geom_violin.rb

@@ -23,10 +23,7 @@
 
 require 'galaaz'
 require 'ggplot'
-
-# Package Hmisc does not yet install on graalvm because of
-# problems with package data.table
-# Polyglot.eval("R", "library('Hmisc')")
+R.install_and_loads('Hmisc')
 
 tooth_growth = ~:ToothGrowth
 tooth_growth.dose = tooth_growth.dose.as__factor
@@ -43,13 +40,12 @@ sleep(2)
 R.grid__newpage
 
 # violin plot with mean points (+/- SD)
-# R.stat_summary requires Hmisc
 print e + R.geom_violin(trim: false) + 
       R.stat_summary(fun__data: "mean_sdl",  fun__args: E.list(mult: 1), 
                      geom: "pointrange", color: "red")
 
-# sleep(2)
-# R.grid__newpage
+sleep(2)
+R.grid__newpage
 
 # Combine with box plot
 print e + R.geom_violin(trim: false) + 

data/examples/sthda_ggplot/two_variables_error/geom_crossbar.rb

@@ -24,6 +24,8 @@
 require 'galaaz'
 require 'ggplot'
 
+R.install_and_loads('Hmisc')
+
 df = ~:ToothGrowth
 df.dose = df.dose.as__factor
 puts df.head
@@ -51,7 +53,7 @@ puts df3.head
 R.awt
 
 # Default plot
-print f + R.geom_crossbar
+puts f + R.geom_crossbar
 
 sleep(2)
 R.grid__newpage

data/lib/R_interface/r.rb

@@ -67,7 +67,16 @@ module R
     packages = R.c(libs)
 
     new_packages = packages[!(packages._ :in, R.installed__packages[:all, "Package"])]
+    
     if(new_packages.size > 0)
+      
+      # package 'data_table' cannot be installed by install.packages.  FastR implements
+      # install.fastr.packages for installing 'data_table'
+      if ((R.c('data.table')._ :in, new_packages) >> 0)
+        new_packages = new_packages[!'data_table']
+        R.install__fastr__packages('data_table')
+      end
+      
       puts "The following packages are missing and will be installed:\n #{new_packages}"
       R.install__packages(new_packages)
     end
@@ -89,6 +98,9 @@ end
 require_relative 'rbinary_operators'
 # Unary operators: '!', '@-', etc
 require_relative 'runary_operators'
+# Logical operators
+require_relative 'rlogical_operators'
+
 # Ruby class extensions.  Extends Symbol to allow the creation of
 # expressions using Symbol: (:x > 10)
 require_relative 'ruby_extensions'
@@ -121,12 +133,3 @@ require_relative 'rpkg'
 
 # Class to allow R calling back into Ruby
 require_relative 'ruby_callback'
-
-# R packages and functions needed
-# Requires ggplot for plotting graphics
-# require 'ggplot'
-# require 'knitr'
-
-# Methods to capture a plot sent to a device
-require_relative 'rdevices'
-

data/lib/R_interface/r_methods.rb

@@ -22,9 +22,9 @@
 ##########################################################################################
 
 module R
-  
+
   module Support
-    
+
     #--------------------------------------------------------------------------------------
     # Captures the R output to a variable and returns it. 
     #--------------------------------------------------------------------------------------

data/lib/R_interface/rbinary_operators.rb

@@ -189,27 +189,9 @@ module R
     #
     #--------------------------------------------------------------------------------------
 
-    def &(other_object)
-      exec_bin_oper("`&`", other_object)
-    end
-
-    alias_method :and, :&
-    
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
-    def |(other_object)
-      exec_bin_oper("`|`", other_object)
-    end
-
-    alias_method :or, :|
-
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
     def til(other_object)
+      return R::Support.exec_function_name("`~`", other_object) if
+        ((self.is_a? Symbol) && (self == :all))
       exec_bin_oper("`~`", other_object)
     end
 

data/lib/R_interface/rdata_frame.rb

@@ -25,8 +25,8 @@ module R
 
   class DataFrame < List
     include MDIndexedObject
-    
-    
+    include Enumerable
+
     #--------------------------------------------------------------------------------------
     # Calls the R.qplot adding the data: parameter
     #--------------------------------------------------------------------------------------
@@ -39,26 +39,73 @@ module R
     #
     #--------------------------------------------------------------------------------------
 
-    def each_row
+    def method_missing_assign(column_name, arg)
+      setR_name("`[<-`", R.empty_symbol, column_name, arg)
+    end
+
+    #--------------------------------------------------------------------------------------
+    # subset assign a vector with an index to a value
+    # @param index [Array] The vector index
+    # @param values [R::Object] The values to assign to the index.  Note that
+    # index can span multiple
+    # values, for ex., R.c(2, 3, 5)
+    #--------------------------------------------------------------------------------------
+
+    def []=(index, values)
+
+      # dealing with double indexing function '[['
+      if (index.is_a? Array)
+        setR_name("`[[<-`", R.empty_symbol, *index, values)
+      else
+        setR_name("`[<-`", R.empty_symbol, index, values)
+      end
       
-      (1..nrow << 0).each do |i|
-        yield self[i, :all], self.rownames[i]
+      self
+      
+    end
+    
+    #--------------------------------------------------------------------------------------
+    # Goes through each row of the dataframe and return the whole row as the first element
+    # and the row name (Ruby string) as the second
+    #--------------------------------------------------------------------------------------
+
+    def each_row
+
+      # nrow is the R function that return the number of rows in the dataset.  This
+      # function returns a R::Vector, so we need to extract its first element (<< 0)
+      (1..nrow >> 0).each do |i|
+        yield self[i, :all], self.rownames[i] >> 0
       end
 
     end
 
     #--------------------------------------------------------------------------------------
-    #
+    # Goes through each column of the dataframe and return the whole column as the first
+    # element and the column name (Ruby string) as the second
     #--------------------------------------------------------------------------------------
 
     def each_column
       
-      (1..ncol << 0).each do |i|
-        yield self[:all, i], self.names[i]
+      # ncol is the R function that return the number of columns in the dataset.  This
+      # function returns a R::Vector, so we need to extract its first element (<< 0)
+      (1..ncol >> 0).each do |i|
+        yield self[:all, i], self.names[i] >> 0
       end
       
     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/rdevices.R

@@ -1,15 +1,3 @@
-#" Capture snapshot of current device.
-#"
-#" There's currently no way to capture when a graphics device changes,
-#" except to check its contents after the evaluation of every expression.
-#" This means that only the last plot of a series will be captured.
-#"
-#" @return \code{NULL} if plot is blank or unchanged, otherwise the output of
-#"   \code{\link[grDevices]{recordPlot}}.
-_plot_snapshot = function() {
-    evaluate:::plot_snapshot()
-}
-
 # Function accessible from Galaaz to call non-exported knitr:::chunk_device function
 _ck_dv = function(width, height, record = TRUE, dev, dev.args, dpi, options, 
                   tmp = tempfile()) {

data/lib/R_interface/rexpression.rb

@@ -22,56 +22,7 @@
 ##########################################################################################
 
 module R
-=begin
-  #--------------------------------------------------------------------------------------
-  # 
-  #--------------------------------------------------------------------------------------
-  
-  class Expression
-    include BinaryOperators
-    include ExpBinOp
-    include UnaryOperators
-    include ExpUniOp
-    
-    attr_reader :infix
-    attr_reader :prefix
-    attr_reader :formula
-    attr_accessor :environment
-        
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-    
-    def to_s
-      @infix
-    end
-
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
-    def formula?
-      @formula
-    end
-
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
-    # private
-
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-    
-    def initialize(infix, formula = false)
-      @infix = infix
-      @formula = formula
-      @environment = R.list
-    end
 
-  end
-=end  
   #--------------------------------------------------------------------------------------
   # 
   #--------------------------------------------------------------------------------------
@@ -90,51 +41,3 @@ module R
   
 end
 
-#=========================================================================================
-#
-#=========================================================================================
-=begin
-module E
-
-  #----------------------------------------------------------------------------------------
-  # @param symbol [Symbol]
-  # @param args [Array] arguments to the missing method
-  #----------------------------------------------------------------------------------------
-  
-  def self.method_missing(symbol, *args)
-    name = R::Support.convert_symbol2r(symbol)
-    
-    params = []
-    args.each do |arg|
-      params << R::Expression.parse_expression(arg)
-    end
-    exp = "#{name}(#{params.join(", ")})"
-    
-    # rhs = R.rhs(R.as__formula("~ #{exp}"))
-    # R.enq(rhs)
-    
-    R::Expression.new(exp)
-  end
-  
-#=begin
-  #----------------------------------------------------------------------------------------
-  # @param symbol [Symbol]
-  # @param args [Array] arguments to the missing method
-  #----------------------------------------------------------------------------------------
-  
-  def self.method_missing(symbol, *args)
-    name = R::Support.convert_symbol2r(symbol)
-    R::Language.build(name, *args)
-  end
-#=end
-  
-  #--------------------------------------------------------------------------------------
-  #
-  #--------------------------------------------------------------------------------------
-
-  def self.[](executable)
-    R::RubyCallback.build(executable)
-  end
-
-end
-=end

data/lib/R_interface/rindexed_object.rb

@@ -35,8 +35,9 @@ module R
     #--------------------------------------------------------------------------------------
 
     def [](index)
+
+      # dealing with double indexing function '[['
       if (index.is_a? Array)
-      # R::Support.exec_function_name("`[[`", @r_interop, R.internal_eval(:c, *index))
         R::Support.exec_function(R::Support.dbk_index, @r_interop,
                                  R.internal_eval(:c, *index))
       else
@@ -53,8 +54,16 @@ module R
     #--------------------------------------------------------------------------------------
 
     def []=(index, values)
-      setR_name("`[<-`", index, values)
+
+      # dealing with double indexing function '[['
+      if (index.is_a? Array)
+        setR_name("`[[<-`", *index, values)
+      else
+        setR_name("`[<-`", index, values)
+      end
+      
       self
+      
     end
 
     #--------------------------------------------------------------------------------------
@@ -62,7 +71,7 @@ module R
     #--------------------------------------------------------------------------------------
 
     def size
-      length << 0
+      length >> 0
     end
     
   end

data/lib/R_interface/rlanguage.rb

@@ -25,9 +25,9 @@ module R
   
   class Language < Object
     include BinaryOperators
+    include LogicalOperators
     include ExpBinOp
     include IndexedObject
-    # include CallBinOp
 
     attr_accessor :expression
     

data/lib/R_interface/rlist.rb

@@ -38,6 +38,31 @@ module R
       R::Support.exec_function_name("`+`", @r_interop, other_object.r_interop)
     end
 
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def method_missing_assign(elmt_name, arg)
+      setR_name("`[[<-`", elmt_name, arg)
+    end
+
+    #--------------------------------------------------------------------------------------
+    # When indexing with '[' or '[[' an R object is returned.  Sometimes we need to have
+    # access to an umboxed Ruby element, for instance, in an numeric array, we might want
+    # to receive the actual number that can be used in a Ruby method.  In this case, we
+    # use the '<<' operator.
+    # @return the Ruby element at the given index in the vector
+    #--------------------------------------------------------------------------------------
+
+    def >>(index)
+      raise IndexError.new("index #{index} out of list bounds: 0...#{index - 1}") if
+        (index > (length - 1) >> 0)
+      raise ArgumentError.new("Indexed element is not a vector") if
+        !self[[index + 1]].is_a? R::Vector
+      return nil if (self[[index + 1]].is__null >> 0)
+      self[[index + 1]] >> 0
+    end
+
     #--------------------------------------------------------------------------------------
     # Each cannot return a Enumerator because R is single threaded.  When this restriction
     # is removed, make each return self.to_enum
@@ -46,8 +71,8 @@ module R
     def each
 
       # length is a R::Vector, in order to extract its size as a Ruby number we need to
-      # use the << operator
-      (1..length << 0).each do |i|
+      # use the >> operator
+      (1..length >> 0).each do |i|
         yield self[[i]]
       end
       
@@ -59,8 +84,8 @@ module R
 
     def each_with_index
       
-      (1..length << 0).each do |i|
-        yield self[i], i
+      (1..length >> 0).each do |i|
+        yield self[[i]], i
       end
       
     end