galaaz 0.4.2 → 0.4.5

data/lib/R_interface/r.rb

@@ -21,6 +21,10 @@
 # OR MODIFICATIONS.
 ##########################################################################################
 
+# Load required R libraries
+dir = File.dirname(File.expand_path('.', __FILE__))
+Polyglot.eval_file("#{dir}/r_libs.R")
+
 require_relative 'robject'
 require_relative 'rsupport'
 
@@ -81,15 +85,20 @@ module R
   
 end
 
-# define methods for accessing indexed object: Vector, Lists
-require_relative 'rindexed_object'
-# define methods for accessing multi dimensional indexed objects: Matrix, DataFrames
-require_relative 'rmd_indexed_object'
 # Binary operators: '+', '-', etc
 require_relative 'rbinary_operators'
 # Unary operators: '!', '@-', etc
 require_relative 'runary_operators'
-# Definition of R Vector
+# Ruby class extensions.  Extends Symbol to allow the creation of
+# expressions using Symbol: (:x > 10)
+require_relative 'ruby_extensions'
+
+# define methods for accessing indexed object: Vector, Lists
+require_relative 'rindexed_object'
+# define methods for accessing multi dimensional indexed objects: Matrix, DataFrames
+require_relative 'rmd_indexed_object'
+
+# Definition of R Vector.  Vectors include Unary and Binary operators
 require_relative 'rvector'
 # Definition of R Lists
 require_relative 'rlist'
@@ -110,11 +119,6 @@ require_relative 'rsymbol'
 # Access to package symbols
 require_relative 'rpkg'
 
-# Defines the E module for creating R expressions
-require_relative 'expression'
-# Ruby class extensions.  Extends Symbol to allow the creation of
-# expressions using Symbol: (:x > 10)
-require_relative 'ruby_extensions'
 # Class to allow R calling back into Ruby
 require_relative 'ruby_callback'
 

data/lib/R_interface/r_libs.R

@@ -0,0 +1,9 @@
+list.of.packages <- c('rlang', 'purrr', 'formula.tools', 'lobstr')
+
+new.packages <- list.of.packages[!(list.of.packages %in% installed.packages()[,"Package"])]
+if(length(new.packages)) install.packages(new.packages)
+
+library('formula.tools')
+library('lobstr')
+library('rlang')
+library('purrr')

data/lib/R_interface/r_methods.rb

@@ -22,7 +22,7 @@
 ##########################################################################################
 
 module R
-
+  
   module Support
     
     #--------------------------------------------------------------------------------------
@@ -41,6 +41,21 @@ module R
       R
     end
 
+    def self.capture2
+      Polyglot.eval("R", <<-R)
+        function(obj, ...) {
+          tryCatch({
+            sink(tt <- textConnection("results","w"), split=FALSE, type = c("output", "message"));
+            print(obj, ...);
+            sink();
+            results
+          }, finally = {
+            close(tt);
+          })
+        }
+      R
+    end
+    
     def self.start_capture
       Polyglot.eval("R", <<-R)
         function(cap_variable) {
@@ -59,6 +74,18 @@ module R
       R
     end
 
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def self.dbk_index
+      Polyglot.eval("R", <<-R)
+        function(obj, index) {
+          obj[[index]]
+        }
+      R
+    end
+    
     #--------------------------------------------------------------------------------------
     # multi-dimensional indexing
     #--------------------------------------------------------------------------------------
@@ -89,15 +116,59 @@ module R
     end
 
     #--------------------------------------------------------------------------------------
-    # @bug Needed to create method row__names because dispatch is not working properly
+    #
+    #--------------------------------------------------------------------------------------
+    
+    def self.enquo
+      Polyglot.eval("R", <<-R)
+        function(x, ...) {
+          enquo(x)          
+        } 
+      R
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
     #--------------------------------------------------------------------------------------
 
-    def self.set_row_names
-      Polyglot.eval("R", "function(object, x) row.names(object) <- x")
+    def self.range
+      Polyglot.eval("R", <<-R)
+        function(x, y, neg = FALSE) {
+          e1 = enexpr(x)
+          e2 = enexpr(y)
+          if (neg) {
+            expr(-(!!e1:!!e2))
+          } else {
+            expr(!!e1:!!e2)
+          }
+        }
+      R
     end
 
-    def self.get_row_names
-      Polyglot.eval("R", "function(x) row.names(x)")
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def self.create_bin_expr(operator)
+      is_formula = (operator == "`~`")? 'TRUE' : 'FALSE'
+      Polyglot.eval("R", <<-R)
+        function(op1, op2) {
+          o1 = enexpr(op1)
+          o2 = enexpr(op2)
+          if (typeof(o1) == 'symbol' && o1 == expr(`__`)) {
+            o1 = expr(.)
+          }
+          if (typeof(o2) == 'symbol' && o2 == expr(`__`)) {
+            o2 = expr(.)
+          }
+          exp = expr(#{operator}(!!o1, !!o2))
+          if (#{is_formula}) {
+            as.formula(exp)
+          } else {
+            exp
+          }
+        }
+        R
     end
 
   end

data/lib/R_interface/{expression.rb → r_module_s.rb}

@@ -21,24 +21,23 @@
 # OR MODIFICATIONS.
 ##########################################################################################
 
-module E
-
-  #----------------------------------------------------------------------------------------
-  # @param symbol [Symbol]
-  # @param args [Array] arguments to the missing method
-  #----------------------------------------------------------------------------------------
+module R
   
-  def self.method_missing(symbol, *args)
-    name = R::Support.convert_symbol2r(symbol)
-    R::Language.build(name, *args)
-  end
-
   #--------------------------------------------------------------------------------------
-  #
+  # Module S, is a support module with R functions that we do not want to polute the
+  # R namespace
   #--------------------------------------------------------------------------------------
 
-  def self.[](executable)
-    R::RubyCallback.build(executable)
+  module S
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+    
+    def self.columns(col_ini, col_end, remove: false)
+      R::Support.exec_function(R::Support.range, col_ini, col_end, remove)
+    end
+    
   end
 
 end

data/lib/R_interface/rbinary_operators.rb

@@ -28,76 +28,39 @@ module R
   #--------------------------------------------------------------------------------------
 
   module ExecBinOp
-    
-    #--------------------------------------------------------------------------------------
-    # 
+
     #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------  
 
-    def exec_oper(operator, other_object)
+    def exec_bin_oper(operator, other_object)
       R::Support.exec_function_name(operator, @r_interop, other_object)
     end
-
-  end
-
-  #--------------------------------------------------------------------------------------
-  # Module for binary operators when creating an expression (call)
-  #--------------------------------------------------------------------------------------
-
-  module CallBinOp
-
+       
     #--------------------------------------------------------------------------------------
-    #
+    # 
     #--------------------------------------------------------------------------------------
     
-    def exec_oper(operator, other_object)
-      R::Language.build(operator, self, other_object)
-    end
-
+     def coerce(numeric)
+      [R.c(numeric), self]
+     end
+    
   end
-
+  
   #--------------------------------------------------------------------------------------
-  # Module for binary operators when creating formulas
+  # Module for binary operators when creating an expression (call)
   #--------------------------------------------------------------------------------------
-
-  module FormulaBinOp
+  
+  module CallBinOp
     
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
-    def prep_object(object)
-      
-      case object
-      when :all
-        '.'
-      when R::RSymbol, Symbol
-        object.to_s
-      when R::Language
-        R.deparse(object).substring(2)
-      when String
-        object
-      end
-      
-    end
-
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
     
-    def exec_oper(operator, other_object, response = false)
-
-      o1 = prep_object(self)
-      o2 = prep_object(other_object)
-
-      response ? R.reformulate(o2, response: o1) :
-         R.reformulate(R.paste0(o1, operator.delete("`"), o2))
-      
+    def exec_bin_oper(operator, other_object)
+      R::Language.build(operator, self, other_object)
     end
 
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
   end
 
   #--------------------------------------------------------------------------------------
@@ -111,7 +74,7 @@ module R
     #--------------------------------------------------------------------------------------
 
     def +(other_object)
-      exec_oper("`+`", other_object)
+      exec_bin_oper("`+`", other_object)
     end
     
     #--------------------------------------------------------------------------------------
@@ -119,7 +82,7 @@ module R
     #--------------------------------------------------------------------------------------
 
     def -(other_object)
-      exec_oper("`-`", other_object)
+      exec_bin_oper("`-`", other_object)
     end
 
     #--------------------------------------------------------------------------------------
@@ -127,7 +90,7 @@ module R
     #--------------------------------------------------------------------------------------
 
     def *(other_object)
-      exec_oper("`*`", other_object)
+      exec_bin_oper("`*`", other_object)
     end
 
     #--------------------------------------------------------------------------------------
@@ -135,7 +98,7 @@ module R
     #--------------------------------------------------------------------------------------
 
     def /(other_object)
-      exec_oper("`/`", other_object)
+      exec_bin_oper("`/`", other_object)
     end
 
     #--------------------------------------------------------------------------------------
@@ -143,7 +106,7 @@ module R
     #--------------------------------------------------------------------------------------
 
     def **(other_object)
-      exec_oper("`^`", other_object)
+      exec_bin_oper("`^`", other_object)
     end
 
     #--------------------------------------------------------------------------------------
@@ -151,15 +114,25 @@ module R
     #--------------------------------------------------------------------------------------
 
     def %(other_object)
-      exec_oper("`%%`", other_object)
+      exec_bin_oper("`%%`", other_object)
     end
+    
+    alias_method :mod, :%
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
 
+    def int_div(other_object)
+      exec_bin_oper("`%/%`", other_object)
+    end
+    
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
-    def ==(other_object)
-      exec_oper("`==`", other_object)
+    def eq(other_object)
+      exec_bin_oper("`==`", other_object)
     end
 
     #--------------------------------------------------------------------------------------
@@ -167,63 +140,77 @@ module R
     #--------------------------------------------------------------------------------------
 
     def <(other_object)
-      exec_oper("`<`", other_object)
+      exec_bin_oper("`<`", other_object)
     end
-
+ 
+    alias_method :lt, :<
+    
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     def <=(other_object)
-      exec_oper("`<=`", other_object)
+      exec_bin_oper("`<=`", other_object)
     end
 
+    alias_method :le, :<=
+
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     def >(other_object)
-      exec_oper("`>`", other_object)
+      exec_bin_oper("`>`", other_object)
     end
 
+    alias_method :gt, :>
+    
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     def >=(other_object)
-      exec_oper("`>=`", other_object)
+      exec_bin_oper("`>=`", other_object)
     end
 
+    alias_method :ge, :>=
+    
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     def !=(other_object)
-      exec_oper("`!=`", other_object)
+      exec_bin_oper("`!=`", other_object)
     end
+
+    alias_method :ne, :!=
     
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     def &(other_object)
-      R::Support.exec_function_name("`&`", @r_interop, other_object.r_interop)
+      exec_bin_oper("`&`", other_object)
     end
+
+    alias_method :and, :&
     
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     def |(other_object)
-      R::Support.exec_function_name("`|`", @r_interop, other_object.r_interop)
+      exec_bin_oper("`|`", other_object)
     end
 
+    alias_method :or, :|
+
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
-    def coerce(numeric)
-      [R.c(numeric), self]
+    def til(other_object)
+      exec_bin_oper("`~`", other_object)
     end
 
   end