galaaz 0.5.0 → 2.0.0

data/lib/R_interface/rdata_frame.rb

@@ -1,102 +1,66 @@
-# -*- 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.
-##########################################################################################
-
+# rdata_frame.rb
 module R
-
   class DataFrame < Object
     include IndexedObject
     include MDIndexedObject
 
-    #--------------------------------------------------------------------------------------
-    # Calls the R.qplot adding the data: parameter
-    #--------------------------------------------------------------------------------------
+    # Phase 5.2: unbox entire data.frame via NewBridgeAdapter#pull_dataframe.
+    # This avoids the generic list-unboxing path which relies on scalar-only eval.
+    def unboxed_get(index = nil, depth = 0)
+      return ::R.bridge.pull_dataframe(@r_interop) if index.nil?
+      if index.is_a?(::Integer)
+        # For scalar-like data.frame views (e.g. Arrow/dplyr collect slices), treat
+        # [[i]] as list-column extraction and keep unboxing in Ruby side.
+        val = ::R::Support.eval("#{@r_interop}[[#{index + 1}]]")
+        return val unless val.is_a?(::R::Object)
+        return val.unboxed_get(nil, depth + 1)
+      end
+      super
+    end
+
+    def class
+      ::R::DataFrame
+    end
 
     def qplot(*args)
-      print R.qplot(*args, data: self)
+      # Use R's print so the plot is displayed on the R device with a single argument (avoids "invalid printing digits" from extra args).
+      ::R.print(::R.qplot(*args, data: self))
     end
 
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
     def method_missing_assign(column_name, arg)
-      setR_name("`[<-`", R.empty_symbol, column_name, arg)
+      # Functional form: df <- `[[<-`(df, i = 'col', value = val)
+      res = ::R::Support.exec_function("`[[<-`", self, i: column_name, value: arg)
+      @r_interop = res.r_interop
+      res
     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, *args)
       values = args[-1]
-      idx2 = (args.size > 1)? args[-2] : false
-      
-      # dealing with double indexing function '[['
-      if (index.is_a? Array)
-        setR_name("`[[<-`", R.empty_symbol, *index, values)
+      res = if index.is_a? ::Array
+        ::R::Support.exec_function("`[[<-`", self, i: index, value: values)
       else
-        idx2 ? setR_name("`[<-`", index, idx2, values) :
-          setR_name("`[<-`", R.empty_symbol, index, values)
+        idx2 = (args.size > 1) ? args[-2] : nil
+        if idx2
+          ::R::Support.exec_function("`[<-`", self, i: index, j: idx2, value: values)
+        else
+          ::R::Support.exec_function("`[<-`", self, i: index, value: values)
+        end
       end
-      
+      @r_interop = res.r_interop
       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
-      
-      # 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
-
   end
-  
 end

data/lib/R_interface/rdevice.rb

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+# R::Device: Ruby wrapper for Galaaz plot devices (png, svg, etc.).
+# Uses base R graphics and evaluate::plot_snapshot; no R package "device" required.
+require 'tmpdir'
+require 'fileutils'
+
+module R
+  class Device
+    def ensure_plot_helpers!
+      R.bridge.eval_r(<<~RCODE)
+        if (!exists("evaluate_plot_snapshot", envir = .GlobalEnv, inherits = FALSE)) {
+          .GlobalEnv$evaluate_plot_snapshot <- function() {
+            grDevices::recordPlot()
+          }
+        }
+        if (!exists("galaaz_save_plot", envir = .GlobalEnv, inherits = FALSE)) {
+          .GlobalEnv$galaaz_save_plot <- function(path, dev_type, width, height, dpi) {
+            if (dev_type == "png") {
+              do.call(grDevices::dev.copy, list(
+                device = grDevices::png,
+                filename = path,
+                width = width,
+                height = height,
+                units = "in",
+                res = dpi
+              ))
+            } else if (dev_type == "svg") {
+              do.call(grDevices::dev.copy, list(
+                device = grDevices::svg,
+                filename = path,
+                width = width,
+                height = height
+              ))
+            } else if (dev_type == "pdf") {
+              do.call(grDevices::dev.copy, list(
+                device = grDevices::pdf,
+                file = path,
+                width = width,
+                height = height
+              ))
+            } else {
+              stop(paste("unsupported dev_type:", dev_type))
+            }
+            grDevices::dev.off()
+            path
+          }
+        }
+        invisible(NULL)
+      RCODE
+    end
+
+    def initialize(type, width: 480, height: 480, dpi: 72, record: true, &block)
+      @type = type.to_s
+      @width = width
+      @height = height
+      @dpi = dpi
+      @record = record
+      @block = block
+      @dev_path = nil
+      @opened = false
+      @last_save_target = nil
+    end
+
+    def open
+      return if @opened
+      dir = File.join(Dir.tmpdir, "galaaz_device_#{Process.pid}")
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      @dev_path = File.join(dir, "dev_#{object_id}.#{@type == 'svg' ? 'svg' : 'png'}")
+      w_px = (@width * @dpi).to_i
+      h_px = (@height * @dpi).to_i
+      if @type == 'svg'
+        R.bridge.eval_r("svg('#{@dev_path.gsub("'", "\\\\'")}', width = #{@width}, height = #{@height})")
+      else
+        R.bridge.eval_r("png('#{@dev_path.gsub("'", "\\\\'")}', width = #{w_px}, height = #{h_px}, res = #{@dpi})")
+      end
+      @opened = true
+      yield if block_given?
+    end
+
+    def close
+      return unless @opened
+      R.dev__off
+      @opened = false
+      if @last_save_target && @dev_path && File.exist?(@dev_path)
+        FileUtils.cp(@dev_path, @last_save_target)
+      end
+    end
+
+    def plot_snapshot
+      ensure_plot_helpers!
+      R.evaluate_plot_snapshot
+    end
+
+    def save_plot(plot, name, dev_type, width, height, ext, dpi)
+      out_name = "#{name}.#{ext}"
+      target = out_name.start_with?('/') ? out_name : File.join(Dir.pwd, out_name)
+      if @opened
+        # Persist current page and reopen the device to keep plotting.
+        R.dev__off
+        @opened = false
+        if @dev_path && File.exist?(@dev_path) && File.size(@dev_path).to_i > 0
+          FileUtils.cp(@dev_path, target)
+        end
+        open
+        @last_save_target = nil
+      elsif !@opened && @dev_path && File.exist?(@dev_path) && File.size(@dev_path).to_i > 0
+        @last_save_target = target
+        FileUtils.cp(@dev_path, target)
+      end
+
+      out_name
+    end
+
+    def self.new(type, width: 480, height: 480, dpi: 72, record: true, &block)
+      inst = allocate
+      inst.send(:initialize, type, width: width, height: height, dpi: dpi, record: record, &block)
+      if block_given?
+        inst.open
+        block.call
+        inst.close
+      end
+      inst
+    end
+  end
+end

data/lib/R_interface/renvironment.rb

@@ -30,12 +30,16 @@ module R
   class Environment < Object
     include IndexedObject
 
+    def class
+      ::R::Environment
+    end
+
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
     
     def set(key, value)
-      R.assign(key.to_s, value, pos: self)
+      ::R.assign(key.to_s, value, pos: self)
     end
     
     #--------------------------------------------------------------------------------------
@@ -43,7 +47,7 @@ module R
     #--------------------------------------------------------------------------------------
 
     def get(key)
-      R.get(key.to_s, pos: self)
+      ::R.get(key.to_s, pos: self)
     end
 
     #--------------------------------------------------------------------------------------
@@ -51,12 +55,14 @@ module R
     #--------------------------------------------------------------------------------------
 
     def method_missing(symbol, *args, &block)
-
-      name = R::Support.convert_symbol2r(symbol)
+      name = ::R::Support.convert_symbol2r(symbol)
 
       case
       when name =~ /(.*)=$/
         set($1, args[0])
+      when name == "env_names"
+        # Call R's env_names(env) from Environment so .length is vector length (1), not string length.
+        ::R::Support.exec_function("env_names", self, unbox: false)
       else
         super(symbol, *args, &block)
       end

data/lib/R_interface/rexpression.rb

@@ -28,7 +28,11 @@ module R
   #--------------------------------------------------------------------------------------
   
   class RExpression < Object
-    
+
+    def class
+      ::R::RExpression
+    end
+
     #--------------------------------------------------------------------------------------
     # Builds 
     #--------------------------------------------------------------------------------------

data/lib/R_interface/rindexed_object.rb

@@ -34,14 +34,38 @@ module R
     # @param index [Array] The vector index.
     #--------------------------------------------------------------------------------------
 
-    def [](index)
-
+    def [](*index)
       # dealing with double indexing function '[['
-      if (index.is_a? Array)
-        R::Support.exec_function(R::Support.dbk_index, @r_interop, *index)
+      # If we have multiple indices, or a single array index, use [[ or `[` for names
+      if (index.size > 1) || (index[0].is_a? Array)
+        args = (index.size > 1) ? index : index[0]
+        # For DataFrame with two indices: R's [[i,j]] is row i, col j. R's [[ does not accept character indices; use `[` for row/col names.
+        # When any index is :all, use `[` (single bracket) so R gets m[i,] or m[,j]; `[[` does not accept missing subscript.
+        # When any index is an R object (e.g. vector), use `[`; `[[` only selects one element ("attempt to select more than one element").
+        use_md = (args.size == 2 && self.is_a?(::R::DataFrame) && (args[0].is_a?(::String) || args[0].is_a?(::Symbol) || args[1].is_a?(::String) || args[1].is_a?(::Symbol))) ||
+                 (args.size == 2 && (args[0] == :all || args[1] == :all)) ||
+                 (args.size == 2 && (args[0].is_a?(::R::Object) || args[1].is_a?(::R::Object)))
+        if use_md
+          ::R::Support.exec_function(::R::Support.md_index, self, *args)
+        else
+          ::R::Support.exec_function(::R::Support.dbk_index, self, *args)
+        end
       else
-        R::Support.exec_function_name("`[`", @r_interop, index)
+        if self.is_a?(::R::DataFrame) && index.size == 1 &&
+           (index[0].is_a?(::R::Language) || index[0].is_a?(::R::Object))
+          # For data.frame, a single logical/language index is expected to filter rows.
+          # Evaluate language conditions in data-frame context, then subset df[cond, ].
+          row_filter = index[0].is_a?(::R::Language) ? ::R::Support.exec_function("with", self, index[0]) : index[0]
+          ::R::Support.exec_function(::R::Support.md_index, self, row_filter, :all)
+        else
+          ::R::Support.exec_function_name("`[`", self, *index)
+        end
+      end
+    rescue ::RuntimeError => e
+      if e.message.to_s.include?("incorrect number of subscripts")
+        ::Kernel.raise(::ArgumentError, e.message)
       end
+      ::Kernel.raise(e)
     end
     
     #--------------------------------------------------------------------------------------
@@ -52,17 +76,21 @@ module R
     # values, for ex., R.c(2, 3, 5)
     #--------------------------------------------------------------------------------------
 
-    def []=(index, values)
+    def []=(*args)
+      values = args.pop
+      index = args
 
-      # dealing with double indexing function '[['
-      if (index.is_a? Array)
-        setR_name("`[[<-`", *index, values)
+      # Assign result back to same handle so the object is updated in place (R's x[i] <- v semantics)
+      if (index.size > 1) || (index[0].is_a? Array)
+        all_args = [@r_interop, *index, values].map { |a| ::R::Support.parse_arg(a) }.join(", ")
+        ::R.bridge.eval_r("#{@r_interop} <- `[[<-`(#{all_args})")
       else
-        setR_name("`[<-`", index, values)
+        idx_r = ::R::Support.parse_arg(index[0])
+        vals_r = ::R::Support.parse_arg(values)
+        ::R.bridge.eval_r("#{@r_interop} <- `[<-`(#{@r_interop}, #{idx_r}, #{vals_r})")
       end
-      
+
       self
-      
     end
 
     #--------------------------------------------------------------------------------------
@@ -70,7 +98,7 @@ module R
     #--------------------------------------------------------------------------------------
 
     def size
-      length >> 0
+      length.unboxed_get(0)
     end
     
   end

data/lib/R_interface/rlanguage.rb

@@ -1,80 +1,38 @@
-# -*- 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.
-##########################################################################################
-
+# rlanguage.rb
 module R
-  
   class Language < Object
     include BinaryOperators
     include LogicalOperators
     include ExpBinOp
     include IndexedObject
 
-    attr_accessor :expression
-    
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-
-    def self.to_expression(obj)
-      obj.respond_to?(:expression) ? obj.expression : obj.to_s
+    def class
+      ::R::Language
     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)
-    #--------------------------------------------------------------------------------------
 
+    attr_accessor :expression
+    
     def self.build(function_name, *args)
-      
-      res = R::Language.new(
-        R::Support.eval("as.call").
-          call(R::Support.parse2list(
-                 R::Support.eval(function_name), *args)
-              ))
-      res.expression = "#{Language.to_expression(args[0])} #{function_name.delete("`")} #{Language.to_expression(args[1])}"
+      # function_name is something like '`+`' or '`~`'
+      op = function_name.delete("`").strip
+      lhs = ::R::Support.parse_arg(args[0])
+      rhs = ::R::Support.parse_arg(args[1])
+      r_expr = (op == ":") ? "#{lhs}#{op}#{rhs}" : "#{lhs} #{op} #{rhs}"
+      lhs_display = ::R::Support.expression_display_arg(args[0])
+      rhs_display = ::R::Support.expression_display_arg(args[1])
+      expr_display = (op == ":") ? "#{lhs_display}#{op}#{rhs_display}" : "#{lhs_display} #{op} #{rhs_display}"
+      res = ::R::Language.allocate
+      res.instance_variable_set(:@r_interop, r_expr)
+      res.expression = expr_display
       res
-      
     end
 
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
-    
-    def assign(expression)
-      exec_bin_oper("`<-`", expression).eval
+    def i
+      "I(#{expression})"
     end
-    
-    #--------------------------------------------------------------------------------------
-    #
-    #--------------------------------------------------------------------------------------
 
-    def i
-      "I(#{@expression})"
+    def to_s
+      expression || super
     end
-    
   end
-  
 end