galaaz 0.4.0

data/lib/robject.rb

@@ -0,0 +1,297 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2018 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+require_relative 'r_methods'
+
+module R
+
+  #--------------------------------------------------------------------------------------
+  # 
+  #--------------------------------------------------------------------------------------
+
+  class Object
+    
+    attr_reader :r_interop
+    attr_accessor :statement
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def initialize(r_interop)
+      @r_interop = r_interop
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def as__data__frame
+      R.as__data__frame.call(@r_interop)
+    end
+
+    #--------------------------------------------------------------------------------------
+    # @param r_interop [Interop] pointer to an R object
+    # @return the R object wrapped in a Ruby class
+    #--------------------------------------------------------------------------------------
+
+    def self.build(r_interop)
+
+      # if the value is actually not an r_interop, then just return it: native Ruby
+      # object
+      if (!Truffle::Interop.foreign?(r_interop))
+        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)
+      elsif (R::Support.eval("is.atomic").call(r_interop) == true)
+        Vector.new(r_interop)
+      elsif (R::Support.eval("is.function").call(r_interop) == true)
+        Closure.new(r_interop)
+      elsif (R::Support.eval("is.data.frame").call(r_interop) == true)
+        DataFrame.new(r_interop)
+      elsif (R::Support.eval("is.list").call(r_interop) == true)
+        List.new(r_interop)
+      elsif (R::Support.eval("typeof").call(r_interop) == "language")
+        Language.new(r_interop)
+      elsif (R::Support.eval("typeof").call(r_interop) == "expression")
+        RExpression.new(r_interop)
+      elsif (R::Support.eval("typeof").call(r_interop) == "name")
+        p "i'm of type name"
+        Name.new(r_interop)
+      elsif (R::Support.eval("typeof").call(r_interop) == "symbol")
+        RSymbol.new(r_interop)
+      elsif (R::Support.eval("typeof").call(r_interop) == "environment")
+        Environment.new(r_interop)
+      else # Generic type
+        p "Generic type: #{R::Support.eval("typeof").call(r_interop).to_s}"
+        r_interop
+      end
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def method_missing_assign(column_name, arg)
+      return setR_name("`[<-`", R.empty_symbol, column_name, arg)
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def method_missing(symbol, *args, &block)
+
+      name = R::Support.convert_symbol2r(symbol)
+
+      case
+      when block_given?
+        R::Support.new_scope(symbol, self, *args, &block)
+      when name =~ /(.*)=$/
+        method_missing_assign($1, args[0])
+      when name == "eval"
+        # R function 'eval' needs to be called in a special way, since it expects
+        # the second argument to be an environment.  If the arguments are packed
+        # into a list, then there is no second argument and the function fails to
+        # use the second argument as environment
+        R::Support.r_evaluate(r_interop, *args)
+      when args.length == 0
+        # no arguments: 2 options: either a named item of the object or apply the function
+        # to the object
+        # if name is a named item of the object, then return the named item
+        named = R::Support.eval("`%in%`").
+                  call(name, R::Support.eval("names").call(@r_interop))
+        (false === named || !(true === named || named[0])) ?
+          R::Support.exec_function_name(name, @r_interop) :
+          R::Support.exec_function_name("`[[`", @r_interop, name)
+      else
+        args.unshift(@r_interop)
+        R::Support.exec_function_name(name, *args)
+      end
+        
+    end
+    
+    #----------------------------------------------------------------------------------------
+    # We use the following notation to access binary R functions such as %in%:
+    # R.vec_ "in", list.
+    # @param args [Array] The first element of the array is an R infix function, the other
+    # arguments are the list of arguments for the function.
+    #----------------------------------------------------------------------------------------
+
+    def _(*args)
+      name = "`%#{args.shift.to_s}%`"
+      args.unshift(@r_interop)
+      R::Support.exec_function_name(name, *args)
+    end
+        
+    #--------------------------------------------------------------------------------------
+    # Sets the current object self interop pointer to the returned value of the execution
+    # of the given method with arguments. This method should be called when R will copy
+    # the parameter, but in Ruby we want to hide the copying.
+    # @param [Interop] Interop pointer to R function
+    # @param [Array] Array of arguments 
+    #--------------------------------------------------------------------------------------
+
+    def setR(method, *args)
+      @r_interop = R::Support.exec_function_i(method, @r_interop, *args)
+      self
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def setR_name(method_name, *args)
+      method = R::Support.eval(method_name)
+      setR(method, *args)
+      self
+    end
+
+    #--------------------------------------------------------------------------------------
+    # Sets the names attribute of the object
+    # @param [R::Object] names_vector is an RVector with the list of names.
+    #--------------------------------------------------------------------------------------
+
+    def names=(names_vector)
+      setR_name("`names<-`", names_vector)
+    end
+
+    def names(*args)
+      return R::Support.exec_function_name("names", @r_interop) if (args.length == 0)
+      setR_name("`names<-`", *args)
+      self
+    end
+        
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def rclass=(class_name)
+      setR_name("`class<-`", class_name)
+    end
+
+    def rclass
+      R::Support.exec_function_name("class", @r_interop)
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def comment=(comment_text)
+      setR_name("`comment<-`", comment_text)
+    end
+    
+    def comment
+      R::Support.exec_function_name("comment", @r_interop)
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def dim=(numeric_vector)
+      setR_name("`dim<-`", numeric_vector)
+    end
+
+    def dim
+      R::Support.exec_function_name("dim", @r_interop)
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def dimnames=(names_vector)
+      setR_name("`dimnames<-`", names_vector)
+    end
+
+    def dimnames
+      R::Support.exec_function_name("dimnames", @r_interop)
+    end
+    
+    #--------------------------------------------------------------------------------------
+    # @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
+    end
+      
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def tsp=(numeric_vector)
+      setR_name("`tsp<-`", numeric_vector)
+    end
+
+    def tsp
+      R::Support.exec_function_name("tsp", @r_interop)
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+    
+    def attr=(which: w, value: v)
+      value = (R::Support.interop(value) ? value.r_interop : value)
+      # setR(@@set_attr, which, value)
+      setR_name("`attr<-`", which, value)
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def pp
+      R.print(r_interop)
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def to_s
+      cap = R::Support.capture.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
+    end
+
+  end
+  
+end

data/lib/rpkg.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2018 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+
+module R
+  
+  #----------------------------------------------------------------------------------------
+  # 
+  #----------------------------------------------------------------------------------------
+
+  class Pkg
+
+    def initialize(pkg_name)
+      @pkg_name = pkg_name
+    end
+
+    def method_missing(symbol, *args)
+      p "execute #{@pkg_name}.#{symbol}(#{args})"
+    end
+
+  end
+  
+  #----------------------------------------------------------------------------------------
+  # 
+  #----------------------------------------------------------------------------------------
+
+  def self.const_missing(name)
+    p name
+    Pkg.new(name)
+  end
+
+end
+  

data/lib/rsupport.rb

@@ -0,0 +1,292 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2018 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+
+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
+  # :all symbol, it will be converted to an empty_symbol in R.
+  #--------------------------------------------------------------------------------------
+  
+  @@empty_symbol = Polyglot.eval("R", <<-R)
+    __missing_arg = quote(f(,0));
+    __missing_arg[[2]]
+  R
+
+  def self.empty_symbol
+    @@empty_symbol
+  end
+
+  # 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
+  # puts a list around NA, so that no unboxing occurs.
+  @na = Polyglot.eval("R", <<-R)
+    list(NA)
+  R
+  
+  class NotAvailable < R::Object
+  end
+
+  NA = NotAvailable.new(@na)
+
+  #--------------------------------------------------------------------------------------
+  # This is a support module for evaluating R functions
+  #--------------------------------------------------------------------------------------
+
+  module Support
+
+    # Using this method gives us more control over what happens when calling do.call
+    # and allows for debugging.  Use it in exec_function when debugging is needed.
+    @@exec_from_ruby = Polyglot.eval("R", <<-R)
+      function(build_method, ...) {
+        # print(build_method);
+        # args = list(...);
+        # print(args);
+        res = do.call(...);
+        # 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)
+    end
+
+    #----------------------------------------------------------------------------------------
+    # @param object [Object] Any Ruby object
+    # @return boolean if the object is an interop or not
+    #----------------------------------------------------------------------------------------
+    
+    def self.interop(object)
+      Truffle::Interop.foreign?(object)
+    end
+
+    #----------------------------------------------------------------------------------------
+    # @param arg [Object] A Ruby object to be converted to R to be used by an R function, or
+    # whatever needs it
+    # @return Object that can be used in R
+    #----------------------------------------------------------------------------------------
+
+    def self.parse_arg(arg)
+      
+      case(arg)
+      when Truffle::Interop
+        arg
+      when R::Object
+        arg.r_interop
+      when NegRange
+        final_value = (arg.exclude_end?)? (arg.last - 1) : arg.last
+        R::Support.eval("seq").call(arg.first, final_value)
+      when Range
+        final_value = (arg.exclude_end?)? (arg.last - 1) : arg.last
+        R::Support.eval("seq").call(arg.first, final_value)
+      when :all
+        R.empty_symbol
+      when Symbol
+        arg = R::Support.eval("as.name").call(arg.to_s)
+      when Proc, Method
+        R::RubyCallback.build(arg)
+      else
+        arg
+      end
+
+    end
+    
+    #----------------------------------------------------------------------------------------
+    # Parses the Ruby arguments into a R list of R objects
+    # @param args [Ruby Parameter list]
+    #----------------------------------------------------------------------------------------
+    
+    def self.parse2list(*args)
+      
+      params = Polyglot.eval("R", "list()")
+      
+      args.each_with_index do |arg, i|
+        if (arg.is_a? Hash)
+          arg.each_pair do |key, value|
+            k = key.to_s.gsub(/__/,".")
+            # HAS CHANGED IN RC6... FIX 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
+            # puts a list around NA, so that no unboxing occurs.  We need to treat this
+            # list here
+            if (value.is_a? NotAvailable)
+              # add the key as the name of the NA
+              na_named = R::Support.eval("`names<-`").call(value.r_interop, k)
+              params = R::Support.eval("c").call(params, na_named)
+            else
+              params = R::Support.eval("`[[<-`").
+                         call(params, k, R::Support.parse_arg(value))
+            end
+          end
+        elsif (arg.is_a? NotAvailable)
+          params = R::Support.eval("c").call(params, arg.r_interop)
+        else
+          params = R::Support.eval("`[[<-`").
+                     call(params, i+1, R::Support.parse_arg(arg))
+        end
+      end
+
+      params
+      
+    end
+    
+    #----------------------------------------------------------------------------------------
+    # Converts a Ruby symbol onto an R symbol.  Converts '__' to '.' and 'rclass' to
+    # class
+    # @param symbol [Symbol] A Ruby symbol to convert to R
+    #----------------------------------------------------------------------------------------
+    
+    def self.convert_symbol2r(symbol)
+      name = symbol.to_s
+      # convert '__' to '.'
+      name.gsub!(/__/,".")
+      # Method 'rclass' is a substitute for R method 'class'.  Needed, as 'class' is also
+      # a Ruby method on an object
+      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
+    # @param internal [Boolean] true if returning to an internal object, i.e., does not
+    # wrap the return object in a Ruby object
+    # @args [Array] Array of arguments for the function
+    #----------------------------------------------------------------------------------------
+    
+    def self.exec_function(function, *args)
+      # function has no arguments, call it directly
+      if (args.length == 0)
+        return R::Object.build(function.call) # if args.length == 0
+      end
+
+      pl = R::Support.parse2list(*args)
+      @@exec_from_ruby.call(R::Object.method(:build), function, pl)
+      # R::Object.build(R::Support.eval("do.call").call(function, pl))
+    end
+    
+    #----------------------------------------------------------------------------------------
+    # @param function_name [String] Name of the R function to execute
+    # @param internal [Boolean] true if returning to an internal object, i.e., does not
+    # wrap the return object in a Ruby object
+    # @args [Array] Array of arguments for the function
+    #----------------------------------------------------------------------------------------
+    
+    def self.exec_function_name(function_name, *args)
+      R::Support.exec_function(R::Support.eval(function_name), *args)
+    end
+
+    #----------------------------------------------------------------------------------------
+    # sets the R symbol <name> to the given value
+    # @param name [String] String representation of the R symbol that needs to be assigned
+    # @param args [Array] Array with one object to be set to the symbol
+    #----------------------------------------------------------------------------------------
+
+    def self.set_symbol(name, *args)
+      args << R::Support.eval("globalenv").call()
+      R::Support.exec_function_name("assign", name, *args)
+    end
+    
+    #----------------------------------------------------------------------------------------
+    # Calls the R 'eval' function.  This requires some special semantics
+    # R function 'eval' needs to be called in a special way, since it expects
+    # the second argument to be an environment.  If the arguments are packed
+    # into a list, then there is no second argument and the function fails to
+    # use the second argument as environment
+    #----------------------------------------------------------------------------------------
+
+    def self.r_evaluate(*args)
+      r_args = args.map { |arg| R::Support.parse_arg(arg) }
+      R::Object.build(eval("eval").call(*r_args))
+    end
+
+    #----------------------------------------------------------------------------------------
+    # Process the missing method
+    # @param symbol [Symbol]
+    # @param internal [Boolean] true if the method will return to an internal method, i.e.,
+    # it should not wrap the return value inside an R::Object
+    # @param object [Ruby Object] the ruby object to which the method is applied, false if
+    # it is not applied to an object
+    #----------------------------------------------------------------------------------------
+
+    def self.process_missing(symbol, internal, *args)
+
+      name = R::Support.convert_symbol2r(symbol)
+      
+      case name
+      # missing method has an '=' sign in it...
+      when ->(x) { x =~ /(.*)=$/ }
+        R::Support.set_symbol($1, *args)
+      # missing method is 'eval'... needs special treatment
+      when "eval"
+        R::Support.r_evaluate(*args)
+      else
+        function = R::Support.eval(name)
+        internal ? R::Support.exec_function_i(function, *args) :
+          R::Support.exec_function(function, *args)
+      end
+      
+    end
+    
+    #----------------------------------------------------------------------------------------
+    # Prints a foreign R interop pointer. Used for debug.
+    #----------------------------------------------------------------------------------------
+
+    def self.print_foreign(interop)
+      puts "===External value==="
+      R::Support.eval("print").call(interop)
+      puts "===end external value==="
+    end
+
+    class << self
+      alias :pf :print_foreign
+    end
+    
+    #----------------------------------------------------------------------------------------
+    #
+    #----------------------------------------------------------------------------------------
+
+  end
+  
+end
+
+require_relative 'rsupport_scope'