galaaz 0.4.2 → 0.4.5

data/lib/R_interface/rdata_frame.rb

@@ -25,7 +25,8 @@ module R
 
   class DataFrame < List
     include MDIndexedObject
-
+    
+    
     #--------------------------------------------------------------------------------------
     # Calls the R.qplot adding the data: parameter
     #--------------------------------------------------------------------------------------

data/lib/R_interface/rdevices.R

@@ -29,3 +29,7 @@ knitr_save_plot = function(plot, name, dev, width, height, ext, dpi, options) {
 knitr_opts_chunk = function() {
     knitr:::opts_chunk
 }
+
+evaluate_plot_snapshot = function() {
+    evaluate:::plot_snapshot()
+}

data/lib/R_interface/rdevices.rb

@@ -168,7 +168,7 @@ module R
   # 
   #--------------------------------------------------------------------------------------
   
-  class Panel <  Device
+  class Panel < Device
     include Singleton
 
     #--------------------------------------------------------------------------------------

data/lib/R_interface/renvironment.rb

@@ -28,7 +28,40 @@ module R
   #--------------------------------------------------------------------------------------
 
   class Environment < Object
+    include IndexedObject
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
     
-  end
+    def set(key, value)
+      R.assign(key.to_s, value, pos: self)
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def get(key)
+      R.get(key.to_s, pos: self)
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
 
+    def method_missing(symbol, *args, &block)
+
+      name = R::Support.convert_symbol2r(symbol)
+
+      case
+      when name =~ /(.*)=$/
+        set($1, args[0])
+      else
+        super(symbol, *args, &block)
+      end
+    end
+    
+  end
+  
 end

data/lib/R_interface/rexpression.rb

@@ -22,13 +22,119 @@
 ##########################################################################################
 
 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  
+  #--------------------------------------------------------------------------------------
+  # 
+  #--------------------------------------------------------------------------------------
+  
   class RExpression < Object
     
+    #--------------------------------------------------------------------------------------
+    # Builds 
+    #--------------------------------------------------------------------------------------
+
+    def self.build(expression)
+      R.parse(text: expression.to_s)
+    end
+    
+  end
+  
+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

@@ -36,7 +36,9 @@ module R
 
     def [](index)
       if (index.is_a? Array)
-        R::Support.exec_function_name("`[[`", @r_interop, R.internal_eval(:c, *index))
+      # 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
         R::Support.exec_function_name("`[`", @r_interop, index)
       end

data/lib/R_interface/rlanguage.rb

@@ -25,7 +25,9 @@ module R
   
   class Language < Object
     include BinaryOperators
-    include FormulaBinOp
+    include ExpBinOp
+    include IndexedObject
+    # include CallBinOp
 
     attr_accessor :expression
     
@@ -38,10 +40,15 @@ module R
     end
     
     #--------------------------------------------------------------------------------------
-    #
+    # Builds a call functions with the given arguments. 
+    # @param function_name [String] name of the function to apply: ex: '+'
+    # @param args [Array] two elements array for the binary function: ex [:a, :b]
+    # @return call expression.  With the above paramenters the result would be:
+    #    .Primitive("+")(a, b)
     #--------------------------------------------------------------------------------------
 
     def self.build(function_name, *args)
+      
       res = R::Language.new(
         R::Support.eval("as.call").
           call(R::Support.parse2list(
@@ -49,8 +56,17 @@ module R
               ))
       res.expression = "#{Language.to_expression(args[0])} #{function_name.delete("`")} #{Language.to_expression(args[1])}"
       res
+      
     end
 
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+    
+    def assign(expression)
+      exec_bin_oper("`<-`", expression).eval
+    end
+    
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------

data/lib/R_interface/rmatrix.rb

@@ -32,6 +32,20 @@ module R
     include BinaryOperators
     include ExecBinOp
     include UnaryOperators
+    include ExecUniOp
+
+    #--------------------------------------------------------------------------------------
+    # 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)
+      @r_interop[index]
+    end
+
   end
   
 end

data/lib/R_interface/rmd_indexed_object.rb

@@ -35,7 +35,11 @@ module R
     #--------------------------------------------------------------------------------------
 
     def [](*index)
-      R::Support.exec_function(R::Support.md_index, @r_interop, *index)
+      if (index.size > 1)
+        R::Support.exec_function(R::Support.md_index, @r_interop, *index)
+      else
+        super(*index)
+      end
     end
 
   end

data/lib/R_interface/robject.rb

@@ -24,7 +24,7 @@
 require_relative 'r_methods'
 
 module R
-
+  
   #--------------------------------------------------------------------------------------
   # 
   #--------------------------------------------------------------------------------------
@@ -43,13 +43,36 @@ module R
     end
 
     #--------------------------------------------------------------------------------------
-    #
+    # Checks for equality between two R::Objects.  This method is used by rspec's
+    # expectation. It returns a Ruby true or false and not an R::Vector with [TRUE] or
+    # [FALSE]
+    #--------------------------------------------------------------------------------------
+
+    def ==(other_object)
+      res = R::Support.exec_function_name("`==`", @r_interop, other_object)
+      return nil if (res.length << 0) == 0
+      res << 0
+    end
+
+    #--------------------------------------------------------------------------------------
+    # Use eql to check for equality between two objects and receive in return an R::Vector
     #--------------------------------------------------------------------------------------
 
-    def as__data__frame
-      R.as__data__frame.call(@r_interop)
+    def eql(other_object)
+      # exec_bin_oper("`==`", other_object)
+      R::Support.exec_function_name("`==`", @r_interop, 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
     # @return the R object wrapped in a Ruby class
@@ -60,30 +83,42 @@ module R
       # if the value is actually not an r_interop, then just return it: native Ruby
       # object
       if (!Truffle::Interop.foreign?(r_interop))
+        # puts "I'm native"
         return r_interop
       # a matrix is also a vector... test should come before
       elsif (R::Support.eval("is.matrix").call(r_interop) == true)
-        Matrix.new(r_interop)
+        # puts "1"
+        R::Matrix.new(r_interop)
       elsif (R::Support.eval("is.atomic").call(r_interop) == true)
+        # puts "2"
         Vector.new(r_interop)
       elsif (R::Support.eval("is.function").call(r_interop) == true)
+        # puts "3"
         Closure.new(r_interop)
       elsif (R::Support.eval("is.data.frame").call(r_interop) == true)
+        # puts "4"
         DataFrame.new(r_interop)
       elsif (R::Support.eval("is.list").call(r_interop) == true)
+        # puts "5"
         List.new(r_interop)
       elsif (R::Support.eval("typeof").call(r_interop) == "language")
+        # puts "6"
         Language.new(r_interop)
       elsif (R::Support.eval("typeof").call(r_interop) == "expression")
+        # puts "7"
         RExpression.new(r_interop)
       elsif (R::Support.eval("typeof").call(r_interop) == "name")
+        # puts "8"
         p "i'm of type name"
         Name.new(r_interop)
       elsif (R::Support.eval("typeof").call(r_interop) == "symbol")
+        # puts "9"
         RSymbol.new(r_interop)
       elsif (R::Support.eval("typeof").call(r_interop) == "environment")
+        # puts "10"
         Environment.new(r_interop)
       else # Generic type
+        # puts "11"
         p "Generic type: #{R::Support.eval("typeof").call(r_interop).to_s}"
         r_interop
       end
@@ -191,7 +226,7 @@ module R
     def rclass=(class_name)
       setR_name("`class<-`", class_name)
     end
-
+    
     def rclass
       R::Support.exec_function_name("class", @r_interop)
     end
@@ -236,16 +271,15 @@ module R
     # @bug Needed to create method R.row__names because dispatch is not working properly
     #--------------------------------------------------------------------------------------
 
-    def row__names
-      R::Support.exec_function(R::Support.get_row_names, @r_interop)
-    end
-
     # since we need to call a method and the method changes the object, then we need to
     # change our internal pointer also @r_interop.  Ideally, just setting the row.names
     # should work.
     def row__names=(names_vector)
-      @r_interop = R::Support.set_row_names.call(@r_interop, names_vector.r_interop)
-      self
+      setR_name("`row.names<-`", names_vector)
+    end
+
+    def row__names
+      R::Support.exec_function_name("row.names", @r_interop)
     end
       
     #--------------------------------------------------------------------------------------
@@ -284,19 +318,23 @@ module R
 
     def to_s
 
-      cap = nil
-      # dev = R::Device.new('png', width: 5, height: 7, dpi: 300, record: true) {
-      cap = R::Support.capture.call(r_interop)
-      # cap = R::Support.capture_output.call(r_interop)
-      # }
-      str = String.new
-      (0...(cap.size - 1)).each do |i|
-        str << cap[i] << "\n"
+      begin
+        
+        cap = nil
+        cap = R::Support.capture2.call(r_interop)
+        str = String.new
+        (0...(cap.size - 1)).each do |i|
+          str << cap[i] << "\n"
+        end
+        str << cap[cap.size - 1] if cap.size >= 1
+        str
+        
+      rescue StandardError => e
+        puts e
       end
-      str << cap[cap.size - 1] if cap.size >= 1
-      str
+      
     end
-
+    
   end
   
 end

data/lib/R_interface/rsupport.rb

@@ -23,7 +23,7 @@
 
 
 module R
-
+  
   #--------------------------------------------------------------------------------------
   # The empty_symbol is necessary to represent indexing with a missing argument such
   # as [x, ].  What follows the ',' is an empty_symbol.  Whenever we use in Ruby the
@@ -64,24 +64,33 @@ module R
     @@exec_from_ruby = Polyglot.eval("R", <<-R)
       function(build_method, ...) {
         # print(build_method);
-        # print("exec_from_ruby")
+        # print("exec_from_ruby");
         # args = list(...);
         # print(args);
-        res = do.call(...);
+
+        # function 'invoke' from package rlang should do a cleaner than
+        # do.call (this is what the documentation says).
+        # res = do.call(...);
+        res = invoke(...);
+
         # print(res);
         res2 = build_method(res);
         # print(res2);
         res2
       }
     R
-    
+        
     #----------------------------------------------------------------------------------------
     # Evaluates an R code
     # @param string [String] A string of R code that can be correctly parsed by R
     #----------------------------------------------------------------------------------------
     
     def self.eval(string)
-      Polyglot.eval("R", string)
+      begin
+        Polyglot.eval("R", string)
+      rescue RuntimeError
+        raise NoMethodError.new("Method #{string} not found in R environment")
+      end
     end
 
     #----------------------------------------------------------------------------------------
@@ -92,7 +101,31 @@ module R
     def self.interop(object)
       Truffle::Interop.foreign?(object)
     end
+    
+=begin
+    #----------------------------------------------------------------------------------------
+    # Builds a quo or a formula based on the given expression.  If the expression has a
+    # '=~' operator, then a formula should be constructed, if not, then an quo should be
+    # constructed
+    # @param expression [R::Expression]
+    # @return quo or formula
+    #----------------------------------------------------------------------------------------
+
+    def self.quo_or_formula(expression)
 
+      if expression.formula?
+        R.as__formula(expression.infix)
+      else
+        # add a '~' before the expression so we can parse it as an
+        # R expression from a string.  Didn't find a good way of creating an
+        # expression from string.
+        # R.as_quosure(R.as__formula("~ #{expression.infix}"))
+        R.rhs(R.as__formula("~ #{expression.infix}"))
+      end
+      
+    end
+=end
+    
     #----------------------------------------------------------------------------------------
     # @param arg [Object] A Ruby object to be converted to R to be used by an R function, or
     # whatever needs it
@@ -100,12 +133,11 @@ module R
     #----------------------------------------------------------------------------------------
 
     def self.parse_arg(arg)
-      
+
       case(arg)
-      when Truffle::Interop
+      when -> (arg) { interop(arg) }
         arg
       when R::Object
-        # return (Truffle::Interop.null?(arg.r_interop)) ? nil : arg.r_interop
         arg.r_interop
       when NegRange
         final_value = (arg.exclude_end?)? (arg.last - 1) : arg.last
@@ -116,10 +148,12 @@ module R
       when :all
         R.empty_symbol
       when Symbol
-        arg = R::Support.eval("as.name").call(arg.to_s)
+        arg = R::Support.eval("as.name").call(arg.to_s.gsub(/__/,"."))
       when Proc, Method
         R::RubyCallback.build(arg)
-      else
+      # when R::Expression
+      #  R::Support.quo_or_formula(arg).r_interop
+      else # This is already a Ruby argument
         arg
       end
 
@@ -138,7 +172,7 @@ module R
         if (arg.is_a? Hash)
           arg.each_pair do |key, value|
             k = key.to_s.gsub(/__/,".")
-            # HAS CHANGED IN RC6... FIXME: THIS TO THE NEW API
+            # HAS CHANGED IN RC6... @TODO: THIS TO THE NEW API
             # When evaluating to NA, Interop treats it as FALSE.  This breaks
             # all expectations about NA.  We need to protect NA from Interop
             # unboxing.  Class NotAvailable
@@ -183,15 +217,6 @@ module R
       name.gsub!("rclass", "class")
       name
     end
-
-    #----------------------------------------------------------------------------------------
-    # Executes the given R function with the given arguments.
-    #----------------------------------------------------------------------------------------
-    
-    def self.exec_function_i(function, *args)
-      pl = R::Support.parse2list(*args)
-      R::Support.eval("do.call").call(function, pl)
-    end
     
     #----------------------------------------------------------------------------------------
     # @param function [R function (Interop)] R function to execute
@@ -202,42 +227,49 @@ module R
     
     def self.exec_function(function, *args)
 
-      # If the execution counter is 0, function was not recursively called
-      # Starts capturing output
-      if (@@exec_counter == 0)
-        R::Support.eval("unlockBinding('r_capture', globalenv())")
-        @@con = R::Support.start_capture.call("r_capture")
-      end
-
-      @@exec_counter = @@exec_counter + 1
-      
-      # function has no arguments, call it directly
-      if (args.length == 0)
-        res = R::Object.build(function.call)
-      else
-        pl = R::Support.parse2list(*args)
-        res = @@exec_from_ruby.call(R::Object.method(:build), function, pl)
-        # R::Object.build(R::Support.eval("do.call").call(function, pl))
-      end
-
-      @@exec_counter = @@exec_counter - 1
-
-      # When execution counter back to 0, print the captured output if the lenght
-      # of the output is greater than 0
-      if (@@exec_counter == 0)
-        R::Support.stop_capture.call(@@con)
+      begin
+        
+        # If the execution counter is 0, function was not recursively called
+        # Starts capturing output
+        if (@@exec_counter == 0)
+          R::Support.eval("unlockBinding('r_capture', globalenv())")
+          @@con = R::Support.start_capture.call("r_capture")
+        end
         
-        if (R::Support.eval("length(r_capture) > 0")[0])
-          cap = R::Object.build(R::Support.eval("r_capture"))
-          # puts ~:r_capture if (R::Support.eval("length(r_capture) > 0")[0])
-          (0...cap.size).each do |i|
-            puts cap << i
+        @@exec_counter = @@exec_counter + 1
+        
+        # function has no arguments, call it directly
+        if (args.length == 0)
+          res = R::Object.build(function.call)
+        else
+          pl = R::Support.parse2list(*args)
+          res = @@exec_from_ruby.call(R::Object.method(:build), function, pl)
+          # R::Object.build(R::Support.eval("do.call").call(function, pl))
+        end
+        
+        @@exec_counter = @@exec_counter - 1
+        
+        # When execution counter back to 0, print the captured output if the length
+        # of the output is greater than 0
+        if (@@exec_counter == 0)
+          R::Support.stop_capture.call(@@con)
+          
+          if (R::Support.eval("length(r_capture) > 0")[0])
+            cap = R::Object.build(R::Support.eval("r_capture"))
+            (0...cap.size).each do |i|
+              puts cap << i
+            end
           end
+          
         end
         
+      rescue StandardError => e
+        R::Support.stop_capture.call(@@con)
+        raise e
       end
-
+      
       res
+      
     end
     
     #----------------------------------------------------------------------------------------
@@ -251,6 +283,15 @@ module R
       R::Support.exec_function(f, *args)
     end
 
+    #----------------------------------------------------------------------------------------
+    # Executes the given R function with the given arguments.
+    #----------------------------------------------------------------------------------------
+    
+    def self.exec_function_i(function, *args)
+      pl = R::Support.parse2list(*args)
+      R::Support.eval("do.call").call(function, pl)
+    end
+
     #----------------------------------------------------------------------------------------
     # sets the R symbol <name> to the given value
     # @param name [String] String representation of the R symbol that needs to be assigned
@@ -272,7 +313,7 @@ module R
 
     def self.r_evaluate(*args)
       r_args = args.map { |arg| R::Support.parse_arg(arg) }
-      R::Object.build(eval("eval").call(*r_args))
+      R::Object.build(R::Support.eval("eval").call(*r_args))
     end
 
     #----------------------------------------------------------------------------------------
@@ -303,6 +344,22 @@ module R
 
     end
     
+    #----------------------------------------------------------------------------------------
+    #
+    #----------------------------------------------------------------------------------------
+
+
+    def self.print_str(obj)
+      
+      lst = obj.as__list
+      puts lst
+=begin      
+      (1..lst.length << 0).each do |i|
+        puts lst[[i]]
+      end
+=end      
+    end
+
     #----------------------------------------------------------------------------------------
     # Prints a foreign R interop pointer. Used for debug.
     #----------------------------------------------------------------------------------------
@@ -316,13 +373,14 @@ module R
     class << self
       alias :pf :print_foreign
     end
-    
+        
     #----------------------------------------------------------------------------------------
     #
     #----------------------------------------------------------------------------------------
-
+    
   end
   
 end
 
+require_relative 'r_module_s'
 require_relative 'rsupport_scope'