galaaz 0.4.7 → 0.4.8

data/examples/islr/ch2.spec.rb

@@ -121,7 +121,7 @@ context "ISLR" do
     it "should create a jpeg file" do
       R.jpeg("/home/rbotafogo/desenv/galaaz/examples/islr/x_y_rnorm.jpg")
       R.df = R.data__frame(x: R.rnorm(100), y: R.rnorm(100))
-      puts R.qplot(:df.x, :df.y, col: "green")
+      puts R.qplot(:x, :y, data: :df, col: "green")
       R.dev__off
     end
 

data/examples/islr/ch3_boston.rb

@@ -51,7 +51,7 @@ puts boston.medv
 
 R.awt
 
-puts R.qplot(:Boston.lstat, :Boston.medv, col: "red") +
+puts R.qplot(:lstat, :medv, data: :Boston, col: "red") +
      R.geom_abline(intercept: boston_lm.coef[1],
                    slope: boston_lm.coef[2],
                    color: "blue",
@@ -66,13 +66,13 @@ sleep(2)
 R.grid__newpage
 
 R.my_data = R.data__frame(pred: R.predict(boston_lm), res: R.residuals(boston_lm))
-puts R.qplot(:my_data.pred, :my_data.res)
+puts R.qplot(:pred, :res, data: :my_data)
 
 sleep(2)
 R.grid__newpage
 
 R.my_data = R.data__frame(pred: R.predict(boston_lm), res: R.rstudent(boston_lm))
-puts R.qplot(:my_data.pred, :my_data.res)
+puts R.qplot(:pred, :res, data: :my_data)
 
 sleep(2)
 R.grid__newpage
@@ -80,7 +80,7 @@ R.grid__newpage
 vals = R.hatvalues(boston_lm)
 R.my_data = R.data__frame(size: (1..vals.size), values: vals)
 # method size returns a Numeric... size is equivalent to 'length << 0'
-puts R.qplot(:my_data.size, :my_data.values)
+puts R.qplot(:size, :values, data: :my_data)
 
 sleep(2)
 R.grid__newpage

data/lib/R_interface/r.rb

@@ -23,7 +23,7 @@
 
 # Load required R libraries
 dir = File.dirname(File.expand_path('.', __FILE__))
-Polyglot.eval_file("#{dir}/r_libs.R")
+Polyglot.eval_file('R', "#{dir}/r_libs.R")
 
 require_relative 'robject'
 require_relative 'rsupport'

data/lib/R_interface/r_methods.rb

@@ -80,8 +80,8 @@ module R
 
     def self.dbk_index
       Polyglot.eval("R", <<-R)
-        function(obj, index) {
-          obj[[index]]
+        function(obj, ...) {
+          obj[[...]]
         }
       R
     end

data/lib/R_interface/rdata_frame.rb

@@ -23,9 +23,9 @@
 
 module R
 
-  class DataFrame < List
+  class DataFrame < Object
+    include IndexedObject
     include MDIndexedObject
-    include Enumerable
 
     #--------------------------------------------------------------------------------------
     # Calls the R.qplot adding the data: parameter
@@ -51,13 +51,16 @@ module R
     # values, for ex., R.c(2, 3, 5)
     #--------------------------------------------------------------------------------------
 
-    def []=(index, values)
-
+    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)
       else
-        setR_name("`[<-`", R.empty_symbol, index, values)
+        idx2 ? setR_name("`[<-`", index, idx2, values) :
+          setR_name("`[<-`", R.empty_symbol, index, values)
       end
       
       self

data/lib/R_interface/rindexed_object.rb

@@ -38,8 +38,7 @@ module R
 
       # dealing with double indexing function '[['
       if (index.is_a? Array)
-        R::Support.exec_function(R::Support.dbk_index, @r_interop,
-                                 R.internal_eval(:c, *index))
+        R::Support.exec_function(R::Support.dbk_index, @r_interop, *index)
       else
         R::Support.exec_function_name("`[`", @r_interop, index)
       end

data/lib/R_interface/rlist.rb

@@ -29,6 +29,7 @@ module R
 
   class List < Object
     include IndexedObject
+    include Enumerable
     
     #--------------------------------------------------------------------------------------
     #

data/lib/R_interface/robject.rb

@@ -149,7 +149,6 @@ module R
     #--------------------------------------------------------------------------------------
 
     def method_missing(symbol, *args, &block)
-
       name = R::Support.convert_symbol2r(symbol)
 
       # Need to raise a NoMethodError when method_missing is called by an implicit

data/lib/R_interface/rpkg.rb

@@ -28,16 +28,25 @@ module R
   # 
   #----------------------------------------------------------------------------------------
 
-  class Pkg
+  class Package
 
-    def initialize(pkg_name)
-      @pkg_name = pkg_name
+    @@packages = {}
+    
+    def self.[](package_name)
+      return @@packages[package_name] if @@packages.has_key?(package_name)
+      @@packages[package_name] = new(package_name)
     end
 
+    def initialize(package_name)
+      @package_name = package_name
+    end
+    
     def method_missing(symbol, *args)
-      p "execute #{@pkg_name}.#{symbol}(#{args})"
+      R::Support.exec_function_name("#{@package_name}::#{symbol}", *args)
     end
 
+    private_class_method :new
+    
   end
   
   #----------------------------------------------------------------------------------------
@@ -45,8 +54,7 @@ module R
   #----------------------------------------------------------------------------------------
 
   def self.const_missing(name)
-    p name
-    Pkg.new(name)
+    R::Package[name.to_s.downcase]
   end
 
 end

data/lib/R_interface/rsupport.rb

@@ -29,7 +29,7 @@ module R
   # 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.
   #--------------------------------------------------------------------------------------
-  
+=begin  
   @@empty_symbol = Polyglot.eval("R", <<-R)
     __missing_arg = quote(f(,0));
     __missing_arg[[2]]
@@ -38,7 +38,12 @@ module R
   def self.empty_symbol
     @@empty_symbol
   end
+=end
 
+  def self.empty_symbol
+    Polyglot.eval("R", "missing_arg()")
+  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.
@@ -63,24 +68,17 @@ module R
     # 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);
-        # print("exec_from_ruby");
-        # args = list(...);
-        # print(args);
-
         # 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
         
     #----------------------------------------------------------------------------------------
+    # @TODO: Fix the 'rescue' clause and open issue with fastR
     # Evaluates an R code
     # @param string [String] A string of R code that can be correctly parsed by R
     #----------------------------------------------------------------------------------------

data/lib/R_interface/ruby_extensions.rb

@@ -20,7 +20,7 @@
 # RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
 # OR MODIFICATIONS.
 ##########################################################################################
-
+#=begin
 module Kernel
 
   def puts(*args)
@@ -29,7 +29,7 @@ module Kernel
   end
 
 end
-
+#=end
 #==========================================================================================
 #
 #==========================================================================================
@@ -185,24 +185,36 @@ class Symbol
 
   def method_missing(symbol, *args, &block)
 
+=begin    
     if (symbol =~ /(.*)=$/)
       # method_missing_assign($1, args[0])
     elsif (args.length == 0 && ((R.c(symbol.to_s)._ :in, R.names(self)) >> 0))
       return self[symbol.to_s]
     end
+=end
     
-    R.send(symbol.to_s, self, *args)
+    E.send(symbol.to_s, self, *args)
     
   end
 
   #--------------------------------------------------------------------------------------
-  #
+  # Used when selecting column in a data frame, from the first column to the var2
+  # column
   #--------------------------------------------------------------------------------------
   
-  def inter(var2)
+  def up_to(var2)
     R::Support.exec_function(R::Support.range, self, var2)
   end
+
+  
+  #--------------------------------------------------------------------------------------
+  # Create an interaction between two variables in formulas
+  #--------------------------------------------------------------------------------------
   
+  def inter(var2)
+    R::Support.exec_function(R::Support.range, self, var2)
+  end
+
   #--------------------------------------------------------------------------------------
   # If method_missing is implemented, then we also need to implement method 'to_ary'.
   # This is because starting from ruby 1.9 the code for Array#flatten has changed,

data/lib/gknit/knitr_engine.rb

@@ -572,9 +572,16 @@ class KnitrEngine
     plot = R.evaluate_plot_snapshot
 
     if (!(plot.is__null >> 0))
-      
+=begin      
+      STDERR.puts "======================"
+      STDERR.puts "in knitr_engine: capture_plot"
+      STDERR.puts @fig__path
+      STDERR.puts @fig__path.class
+      STDERR.puts File.directory?(@fig__path)
+=end      
       # create directory for the graphics files if does not already exists
-      unless File.directory?(@fig__path)
+      # unless File.directory?(@fig__path)
+      unless (R.dir__exists(@fig__path) >> 0)
         FileUtils.mkdir_p(@fig__path)
       end
 

data/lib/util/exec_ruby.rb

@@ -22,7 +22,7 @@
 ##########################################################################################
 
 require 'stringio'
-
+=begin
 #----------------------------------------------------------------------------------------
 # Path StringIO puts... Already opened an issue in RC12
 #----------------------------------------------------------------------------------------
@@ -71,7 +71,7 @@ class StringIO
   end
 
 end
-
+=end
 #----------------------------------------------------------------------------------------
 # Class RubyChunk is used only as a context for all ruby chunks in the rmarkdown file.
 # This allows for chunks to access instance_variables (@)

data/specs/r_dataframe.spec.rb

@@ -72,6 +72,179 @@ describe R::DataFrame do
     end
 
   end
+
+  #----------------------------------------------------------------------------------------
+  context "Subsetting with '['" do
+
+    before(:each) do
+      @mtcars = ~:mtcars
+    end
+
+    it "should subset with [ with only the column index" do
+      slice = @mtcars[1]
+      expect(slice.typeof).to eq "list"
+      expect(slice.rclass).to eq "data.frame"
+      expect(slice.length).to eq 1
+      expect(slice[[1]][1]).to eq 21.0
+      expect(slice[[1, 1]]).to eq 21.0
+      # undefined columns selected (RError)
+      expect { slice['Mazda RX4'] }.to raise_error(RuntimeError)
+      expect(slice[['Mazda RX4']]).to eq nil
+    end
+    
+    it "should subset with [ with a column range" do
+      slice = @mtcars[(1..3)]
+      expect(slice.typeof).to eq "list"
+      expect(slice.rclass).to eq "data.frame"
+      expect(slice.length).to eq 3
+      expect(slice[[2]][10]).to eq 6.0
+      expect(slice[10, 2]).to eq 6.0
+    end
+
+    it "should subset with [ by row and column indices" do
+      expect(@mtcars[1, 1]).to eq 21.0
+      expect(@mtcars[6, 5]).to eq 2.76
+    end
+
+    it "do not use R style missing value idexing with [" do
+      # This array bellow is equivalent to [6]. This can bring some surprises for
+      # R people that are used to this indexing notation, as in this case the ','
+      # is ignored
+      arr = [6, ]
+      expect(arr).to eq [6]
+      
+      # This will output the sixth column of the mtcars dataframe
+      slice = @mtcars[6, ]
+      expect(slice.typeof).to eq "list"
+      expect(slice.rclass).to eq "data.frame"
+      expect(slice.length).to eq 1
+      expect(slice[[1]][1]).to eq 2.62
+    end
+
+    it "should subset with [ by row index and :all" do
+      # Hornet Sportabout 18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2      
+      slice = @mtcars[5, :all]
+      expect(slice.rclass).to eq "data.frame"
+      expect(slice[1, 1]).to eq 18.7
+      expect(slice[1, 1]).not_to eq 360.0
+      expect(slice.names).to eq R.c("mpg", "cyl", "disp", "hp", "drat",
+                                    "wt", "qsec", "vs", "am", "gear", "carb")
+    end
+
+    it "should subset with [ by row index, :all and allowing for drop parameter" do
+      # will transform the data into a list
+      lst = @mtcars[1, :all, drop: true]
+      expect(lst.typeof).to eq "list"
+      expect(lst[[1]]).to eq 21.0
+      expect(lst[1]).to eq R.list(mpg: 21.0)
+    end
+
+    it "should subset with [ by :all and column index" do
+      # [1] 110 110  93 110 175 105 245  62  95 123 123 180 180 180 205 215 230  66  52
+      # [20]  65  97 150 150 245 175  66  91 113 264 175 335 109
+      slice = @mtcars[:all, 4]
+      expect(slice.rclass).to eq "numeric"
+      expect(slice.typeof).to eq "double"
+      expect(slice[10]).to eq 123.0
+    end
+
+    it "should subset with [ by :all, column index and allowing for 'drop' parameter" do
+      expect(@mtcars[:all, 1]).to eq @mtcars[:all, 1, drop: true]
+    end
+
+    it "should subset with [ and column name" do
+      slice = @mtcars['drat']
+      expect(slice.typeof).to eq "list"
+      expect(slice.rclass).to eq "data.frame"
+      expect(slice.length).to eq 1
+      expect(slice[[1]][1]).to eq 3.90
+      expect(slice[[1, 1]]).to eq 3.90
+      # undefined columns selected (RError)
+      expect { slice['Mazda RX4'] }.to raise_error(RuntimeError)
+      expect(slice[['Mazda RX4']]).to eq nil
+    end
+
+    it "should subset with [ and row name" do
+      slice = @mtcars['Merc 450SE', :all]
+      expect(slice[[1]]).to eq 16.4
+      expect(slice[['hp']]).to eq 180.0
+    end
+
+    it "should subset with [ and row and column name" do
+      slice = @mtcars['Merc 450SL', 'drat']
+      expect(slice).to eq 3.07
+    end
+    
+  end
+  
+  #----------------------------------------------------------------------------------------
+  context "Subsetting with '[['" do
+
+    before(:each) do
+      @mtcars = ~:mtcars
+    end
+
+    it "should subset with [[ and a column index" do
+      slice = @mtcars[[1]]
+      expect(slice.typeof).to eq "double"
+      expect(slice.rclass).to eq "numeric"
+      expect(slice[1]).to eq 21.0
+      expect(slice[16]).to eq 10.4
+    end
+
+    it "should subset with [[ and a row index" do
+      slice = @mtcars
+    end
+
+    it "should subset with [[ and row and column indices" do
+      expect(@mtcars[[6, 1]]).to eq 18.1
+      expect(@mtcars[[6, 5]]).to eq 2.76
+      expect(@mtcars[[15, 1]]).to eq 10.4
+      expect(@mtcars[[15, 7]]).to eq 17.98
+    end
+
+    it "should subset with [[ and row and column names" do
+      expect(@mtcars[['Valiant', 'mpg']]).to eq 18.1
+      expect(@mtcars[['Valiant', 'drat']]).to eq 2.76
+      expect(@mtcars[['Cadillac Fleetwood', 'mpg']]).to eq 10.4
+      expect(@mtcars[['Cadillac Fleetwood', 'qsec']]).to eq 17.98
+    end
+
+  end
+  
+  #----------------------------------------------------------------------------------------
+  context "Assigning with '[<-'" do
+
+    before(:each) do
+      @mtcars = ~:mtcars
+    end
+
+    it "should add a column to a dataframe indexing by column" do
+      @mtcars["New Column"] = R.c((1..32))
+      expect(@mtcars[[1, 12]]).to eq 1
+      expect(@mtcars[['Mazda RX4', 'New Column']]).to eq 1
+    end
+
+    it "should add a column to a dataframe indexing with :all in the row" do
+      @mtcars[:all, 'New Column'] = R.c((1..32))
+      expect(@mtcars[[1, 12]]).to eq 1
+      expect(@mtcars[['Mazda RX4', 'New Column']]).to eq 1
+    end
+    
+    it "should assign to an element of a dataframe indexing with row and column by number" do
+      @mtcars[17, 6] = 1000
+      expect(@mtcars[[17, 6]]).to eq 1000.0
+      expect(@mtcars[['Chrysler Imperial', 'wt']]).to eq 1000.0
+    end
+
+    it "should assign to a range" do
+      @mtcars[(10..12)] = R.list((1..32), nil, "New Col": R.c(32..1))
+      expect(@mtcars[['Fiat 128', 'gear']]).to eq 18
+      expect(@mtcars[['Chrysler Imperial', 'New Col']]).to eq 16
+    end
+
+  end
+  
   #----------------------------------------------------------------------------------------
   context "Ruby 'each'" do