galaaz 0.4.5 → 0.4.6

data/lib/R_interface/rlogical_operators.rb

@@ -0,0 +1,50 @@
+# -*- 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
+
+  module LogicalOperators
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def &(other_object)
+      exec_bin_oper("`&`", other_object)
+    end
+
+    alias_method :and, :&
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def |(other_object)
+      exec_bin_oper("`|`", other_object)
+    end
+
+    alias_method :or, :|
+    
+  end
+
+end

data/lib/R_interface/rmatrix.rb

@@ -29,11 +29,17 @@ module R
 
   class Matrix < Object
     include MDIndexedObject
+    # binary operators
     include BinaryOperators
     include ExecBinOp
+
+    # unary operators
     include UnaryOperators
     include ExecUniOp
 
+    # logical operators. Can either be binary or unary
+    include LogicalOperators
+
     #--------------------------------------------------------------------------------------
     # 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
@@ -42,7 +48,7 @@ module R
     # @return the Ruby element at the given index in the vector
     #--------------------------------------------------------------------------------------
 
-    def <<(index)
+    def >>(index)
       @r_interop[index]
     end
 

data/lib/R_interface/robject.rb

@@ -49,9 +49,11 @@ module R
     #--------------------------------------------------------------------------------------
 
     def ==(other_object)
-      res = R::Support.exec_function_name("`==`", @r_interop, other_object)
-      return nil if (res.length << 0) == 0
-      res << 0
+      res =
+        R::Support.exec_function_name('identical', @r_interop,
+                                      R::Support.parse_arg(other_object))
+      return nil if (res.length >> 0) == 0
+      res >> 0
     end
 
     #--------------------------------------------------------------------------------------
@@ -60,7 +62,8 @@ module R
 
     def eql(other_object)
       # exec_bin_oper("`==`", other_object)
-      R::Support.exec_function_name("`==`", @r_interop, other_object)
+      R::Support.exec_function_name("`==`", @r_interop,
+                                    R::Support.parse_arg(other_object))
     end
 
     #--------------------------------------------------------------------------------------
@@ -102,8 +105,14 @@ module R
         # puts "5"
         List.new(r_interop)
       elsif (R::Support.eval("typeof").call(r_interop) == "language")
+        # @TODO: tests are passing both when we use Language.new
+        # and RExpression.new.  Check what should be and write
+        # discriminating tests.
+        # print "robject buid: language\n"
+        # R::Support.print_foreign(r_interop)
         # puts "6"
         Language.new(r_interop)
+        # RExpression.new(r_interop)
       elsif (R::Support.eval("typeof").call(r_interop) == "expression")
         # puts "7"
         RExpression.new(r_interop)
@@ -124,15 +133,17 @@ module R
       end
 
     end
-
+    
+=begin
     #--------------------------------------------------------------------------------------
-    #
+    # This method was moved to DataFrame.  Need to check which other objects can have
+    # values assigned to them
     #--------------------------------------------------------------------------------------
 
     def method_missing_assign(column_name, arg)
       return setR_name("`[<-`", R.empty_symbol, column_name, arg)
     end
-
+=end
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
@@ -141,6 +152,10 @@ module R
 
       name = R::Support.convert_symbol2r(symbol)
 
+      # 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
+      raise NoMethodError if name == "to_ary"
+      
       case
       when block_given?
         R::Support.new_scope(symbol, self, *args, &block)
@@ -151,7 +166,7 @@ module R
         # 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)
+        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
@@ -180,7 +195,7 @@ module R
       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
@@ -195,7 +210,7 @@ module R
     end
 
     #--------------------------------------------------------------------------------------
-    #
+    # 
     #--------------------------------------------------------------------------------------
 
     def setR_name(method_name, *args)
@@ -309,7 +324,7 @@ module R
     #--------------------------------------------------------------------------------------
 
     def pp
-      R.print(r_interop)
+      R.print(@r_interop)
     end
 
     #--------------------------------------------------------------------------------------
@@ -319,7 +334,6 @@ module R
     def to_s
 
       begin
-        
         cap = nil
         cap = R::Support.capture2.call(r_interop)
         str = String.new
@@ -328,13 +342,13 @@ module R
         end
         str << cap[cap.size - 1] if cap.size >= 1
         str
-        
       rescue StandardError => e
         puts e
       end
       
     end
-    
+
   end
-  
+
+    
 end

data/lib/R_interface/rsupport.rb

@@ -72,7 +72,7 @@ module R
         # do.call (this is what the documentation says).
         # res = do.call(...);
         res = invoke(...);
-
+        
         # print(res);
         res2 = build_method(res);
         # print(res2);
@@ -101,31 +101,7 @@ 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
@@ -139,25 +115,55 @@ module R
         arg
       when R::Object
         arg.r_interop
+      when Numeric
+        R::Support.eval('c').call(arg)
       when NegRange
         final_value = (arg.exclude_end?)? (arg.last - 1) : arg.last
-        R::Support.eval("seq").call(arg.first, final_value)
+        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)
+        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.gsub(/__/,"."))
+        arg = R::Support.eval('as.name').call(arg.to_s.gsub(/__/,"."))
       when Proc, Method
         R::RubyCallback.build(arg)
-      # when R::Expression
-      #  R::Support.quo_or_formula(arg).r_interop
-      else # This is already a Ruby argument
+      # This is a Ruby argument that will be automatically converted
+      # by the low level Polyglot interface to R
+      else 
         arg
       end
 
     end
+
+    #----------------------------------------------------------------------------------------
+    # Given a hash, convert it to an R argument list
+    #----------------------------------------------------------------------------------------
+
+    def self.parse_hash(hsh, lst)
+
+      hsh.each_pair do |key, value|
+        k = key.to_s.gsub(/__/,".")
+        
+        case 
+        when (value.is_a? NotAvailable)
+          na_named = R::Support.eval("`names<-`").call(value.r_interop, k)
+          lst = R::Support.eval("c").call(lst, na_named)
+        when (k == 'all')
+          lst = R::Support.eval("`[[<-`").
+                  call(lst, R::Support.eval('`+`').
+                              call(R::Support.eval('length').call(lst), 1),
+                       R::Support.parse_arg(value))
+        else
+          lst = R::Support.eval("`[[<-`").
+                  call(lst, k, R::Support.parse_arg(value))
+        end
+      end
+      
+      lst
+      
+    end
     
     #----------------------------------------------------------------------------------------
     # Parses the Ruby arguments into a R list of R objects
@@ -165,40 +171,25 @@ module R
     #----------------------------------------------------------------------------------------
     
     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... @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
-            # 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
+          params = parse_hash(arg, params)
         elsif (arg.is_a? NotAvailable)
           params = R::Support.eval("c").call(params, arg.r_interop)
+        elsif (arg.is_a? NilClass)
+          params = R::Support.eval("`length<-`").call(params, i+1)
         else
           params = R::Support.eval("`[[<-`").
                      call(params, i+1, R::Support.parse_arg(arg))
         end
       end
-
+      
       # if the parameter is an empty list, then add the element NULL to the list
       (Polyglot.eval("R", "length").call(params) == 0) ?
         Polyglot.eval("R", "list").call(nil) : params
-      # params
       
     end
     
@@ -253,14 +244,14 @@ module R
         # of the output is greater than 0
         if (@@exec_counter == 0)
           R::Support.stop_capture.call(@@con)
-          
+=begin          
           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          
         end
         
       rescue StandardError => e
@@ -278,7 +269,8 @@ module R
     #----------------------------------------------------------------------------------------
     
     def self.exec_function_name(function_name, *args)
-      # TODO: should check the function name before calling eval
+      # @TODO: should check all that can go wrong when calling eval(function_name) to
+      # raise the proper exception
       f = R::Support.eval(function_name)
       R::Support.exec_function(f, *args)
     end
@@ -289,7 +281,7 @@ module R
     
     def self.exec_function_i(function, *args)
       pl = R::Support.parse2list(*args)
-      R::Support.eval("do.call").call(function, pl)
+      R::Support.eval("invoke").call(function, pl)
     end
 
     #----------------------------------------------------------------------------------------
@@ -348,13 +340,12 @@ module R
     #
     #----------------------------------------------------------------------------------------
 
-
     def self.print_str(obj)
       
       lst = obj.as__list
       puts lst
 =begin      
-      (1..lst.length << 0).each do |i|
+      (1..lst.length >> 0).each do |i|
         puts lst[[i]]
       end
 =end      
@@ -384,3 +375,28 @@ end
 
 require_relative 'r_module_s'
 require_relative 'rsupport_scope'
+
+
+=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

data/lib/R_interface/rsymbol.rb

@@ -30,7 +30,8 @@ module R
   class RSymbol < R::Object
     include BinaryOperators
     include ExecBinOp
-    # include FormulaBinOp
+    include LogicalOperators
+    
 =begin    
     #--------------------------------------------------------------------------------------
     #

data/lib/R_interface/ruby_extensions.rb

@@ -106,7 +106,8 @@ end
 class Symbol
   include R::BinaryOperators
   include R::ExpBinOp
-
+  include R::LogicalOperators
+  
   #--------------------------------------------------------------------------------------
   # Unary '+' converts a Ruby Symbol into an R Symbol
   #--------------------------------------------------------------------------------------
@@ -157,6 +158,14 @@ class Symbol
   #
   #--------------------------------------------------------------------------------------
 
+  def assign2(expression)
+    exec_bin_oper("`=`", expression)
+  end
+
+  #--------------------------------------------------------------------------------------
+  #
+  #--------------------------------------------------------------------------------------
+
   def [](index)
     exec_bin_oper("`[[`", index)
   end
@@ -169,7 +178,7 @@ class Symbol
 
     if (symbol =~ /(.*)=$/)
       # method_missing_assign($1, args[0])
-    elsif (args.length == 0 && ((R.c(symbol.to_s)._ :in, R.names(self)) << 0))
+    elsif (args.length == 0 && ((R.c(symbol.to_s)._ :in, R.names(self)) >> 0))
       return self[symbol.to_s]
     end