galaaz 0.4.2 → 0.4.5

data/specs/r_function.spec.rb

@@ -55,8 +55,8 @@ describe R do
       f = R.outer(@x, @y,
                   lambda { |x, y|
                     R.cos(y) / (x**2 + 1)})
-      expect(f[1, 1] == -0.09199967).to eq true
-      expect(f[7, 6] == -0.04599983).to eq true
+      expect(f[1, 1].all__equal -0.091999668).to eq true
+      expect(f[7, 6].all__equal 0.448193475).to eq true
     end
 
     it "should accept a Method as parameter" do
@@ -70,10 +70,9 @@ describe R do
         end
       end
 
-      f = R.outer(@x, @y, Calculation.method(:func))
-      expect(f[1, 1] == -0.09199967).to eq true
-      expect(f[7, 6] == -0.04599983).to eq true
-      
+      f = R.outer(@x, @y, Calculation.method(:func)) 
+      expect(f[1, 1].all__equal -0.091999668).to eq true
+      expect(f[7, 6].all__equal 0.448193475).to eq true
     end
     
     it "should accept Procs in Expressions" do
@@ -85,8 +84,8 @@ describe R do
       
       # now lets evaluate f in the scope of df, where :x and :y are defined
       res = f.eval(df)
-      expect(res[1, 1] == -0.09199967).to eq true
-      expect(res[10, 10] == -0.09199967).to eq true
+      expect(res[1, 1].all__equal -0.091999668).to eq true
+      expect(res[10, 9].all__equal -0.0704758347).to eq true
     end
 
     it "Should be able to 'eval' a Proc in expression" do

data/specs/r_list.spec.rb

@@ -81,6 +81,10 @@ describe R::List do
       expect(@l[R.c(4, 1)].identical(R.list(R.list(4, 5, 6), 1))).to eq true
     end
 
+    it "should raise an exception when index dimension is wrong" do
+      expect { @l[4, 1] }.to raise_error(ArgumentError)
+    end
+
     it "should subset with [[]] and positive integer. Returns the actual element of the list" do
       # to extract an element of a list we need double square (dbk) indexing
       expect(@l[[1]]).to eq 1

data/specs/r_list_apply.spec.rb

@@ -60,8 +60,8 @@ describe R::List do
       quant = R.lapply(@x, @q)
       expect(quant.a[1]).to eq 1
       expect(quant.a["50,00000%"]).to eq 5.50
-      expect(R.all__equal(quant.beta["100,0000%"],
-                          20.08553692,
+      expect(R.all__equal(quant.beta["100%"],
+                          R.c('100%': 20.08553692),
                           tolerance: (~:".Machine").double__eps ** 0.5)).to eq true
       expect(quant.logic[2]).to eq 0.0
     end
@@ -70,28 +70,28 @@ describe R::List do
       x = R.lapply(@x, @q, R.c(0.25, 0.50, 0.75))
       expect(x.a[1]).to eq 3.25
       expect(x.a["50,00000%"]).to eq 5.50
-      expect(R.all__equal(x.beta["75,00000%"],
-                          5.0536690,
+      expect(R.all__equal(x.beta['75%'],
+                          R.c('75%': 5.0536690),
                           tolerance: (~:".Machine").double__eps ** 0.5)).to eq true
       expect(x.logic[2]).to eq 0.5
     end
 
     it "should allow using sapply and quantile" do
       quant = R.sapply(@x, @q)
-      expect quant.rclass == 'matrix'
-      expect quant[:all, 'a'] == R.c(1, 3.25, 5.50, 7.75, 10)
-      expect quant[3, 'beta'] == 1
+      expect(quant.rclass).to eq 'matrix'
+      expect(quant[:all, 'a']).to eq R.c(1, 3.25, 5.50, 7.75, 10)
+      expect(quant[3, 'beta']).to eq 1
     end
     
     it "should sapply to a sequence" do
       # sapply isn’t content to always return a list: it attempts to simplify
       # the results into a non-list vector if possible.
       i39 = R.sapply((3..9), "seq")
-      expect i39[[1]] == R.c(1, 2, 3)
-      expect i39[[7]] == R.c(1, 2, 3, 4, 5, 6, 7, 8, 9)
+      expect(i39[[1]]).to eq R.c(1, 2, 3)
+      expect(i39[[7]]).to eq R.c(1, 2, 3, 4, 5, 6, 7, 8, 9)
       sap = R.sapply(i39, ~:fivenum)
-      expect sap[1, 1] == 1
-      expect sap[5, 7] == 9
+      expect(sap[1, 1]).to eq 1
+      expect(sap[5, 7]).to eq 9
     end
   
   end

data/specs/r_matrix.spec.rb

@@ -23,7 +23,7 @@
 
 require 'galaaz'
 
-describe R do
+describe R::Matrix do
 
   #----------------------------------------------------------------------------------------
   context "Matrices" do
@@ -74,8 +74,8 @@ describe R do
     it "should apply a function to all elements of the matrix: ex: sqrt" do
       x = R.matrix(data: R.c(1, 2, 3, 4), nrow: 2, ncol: 2, byrow: true)
       z = x.sqrt
-      expect(z[1, 2] == 1.73).to eq true
-      expect(z[2, 1] == 1.41).to eq true
+      expect(z[1, 2].all__equal(1.41421356)).to eq true
+      expect(z[2, 1].all__equal(1.73205080)).to eq true
     end      
 
   end

data/specs/{r_plots.spec.rb~ → r_nse.spec.rb}

@@ -23,15 +23,38 @@
 
 require 'galaaz'
 
-describe R::Plots do
-
-  #----------------------------------------------------------------------------------------
-  context "Create a Plot" do
-
-    it "should create a plot with ggplot" do
+describe R do
+  
+  #========================================================================================
+  context "Non-standard Evaluation"  do
 
+    before(:all) do
+      @sample_df = R.data__frame(a: (1..5), b: (5..1), c: R.c(5, 3, 1, 4, 1))
     end
 
+    it "should allow functions to receive objects and conditions for evaluation" do
+      
+      def subset(df, condition)
+        # evaluate the condition in the scope of the dataframe
+        r = R.eval(condition, df)
+        df[r, :all]  
+      end
+
+      puts subset(@sample_df, :a >= 4)
+
+      y = 4
+      x = 4
+      condition = 4
+      condition_call = 4
+
+      puts subset(@sample_df, :a == 4)
+      puts subset(@sample_df, :a == y)
+      puts subset(@sample_df, :a == condition)
+      puts subset(@sample_df, :a == condition_call)
+    end
+    
   end
 
 end
+
+    

data/specs/r_vector_creation.spec.rb

@@ -35,6 +35,12 @@ describe R::Vector do
       expect(log_vect.mode).to eq "logical"
       expect(log_vect.storage__mode).to eq "logical"
     end
+
+    it "should create a vector from a scalar" do
+      vec = R.c(1)
+      expect(vec.length).to eq 1
+      expect(vec.class).to eq R::Vector
+    end
     
     it "should create integer Vectors" do
       # in R, numbers are converted to double.  To get an int one needs to add L after the

data/specs/r_vector_object.spec.rb

@@ -67,12 +67,12 @@ describe R::Vector do
       expect(@vect.rclass).to eq "newClass"
     end
       
-    it "should allow changing an element of a vector attribute" do
+    it "will copy vectors and changes will not be seen" do
       # pending "Need to implement new function for this"
       # set names
       @vect.names = R.c("a", "b", "c", "d", "e", "f")
       @vect.names[2] = "hello"
-      expect(@vect.names[2]).to eq "hello"
+      expect(@vect.names[2]).to eq R.c("b")
     end
     
   end

data/specs/r_vector_operators.spec.rb

@@ -73,7 +73,7 @@ describe R::Vector do
        res = 10 - @vec1
        expect(res == R.c(7, 4.3, 0, -1)).to eq true
        res = 10 / @vec1
-       expect(res == R.c(3.3333333, 1.7543860, 1, 0.8333333)).to eq true
+       expect(res.all__equal R.c(3.333333333, 1.754385964, 1, 0.833333333)).to eq true
      end
      
    end
@@ -86,9 +86,9 @@ describe R::Vector do
        vec2 = R.c(1, 2)
        vec3 = R.c(0, 2)
 
-       expect((vec1 == vec2).all__equal(R.c(true, true))).to eq true
+       expect((vec1.eql vec2).all__equal(R.c(true, true))).to eq true
        expect((vec1 != vec2).all__equal(R.c(false, false))).to eq true
-       expect((vec1 == vec3).all__equal(R.c(false, true))).to eq true
+       expect((vec1.eql vec3).all__equal(R.c(false, true))).to eq true
      end
 
      it "should check vectors for <, <=, >, >=" do

data/specs/r_vector_subsetting.spec.rb

@@ -82,7 +82,7 @@ describe R::Vector do
       # element
       @vect.each_with_index do |elmt, i|
         expect(elmt.typeof == 'integer').to eq true
-        expect elmt == i
+        expect(elmt).to eq i
       end
     end
 
@@ -97,7 +97,7 @@ describe R::Vector do
     it "should subset with 'each_with_index(:native)' getting a Ruby element" do
       # when using the :native keyword, indexing starts at 0
       @vect.each_with_index(:native) do |elmt, i|
-        expect elmt == i + 1
+        expect(elmt).to eq i + 1
       end
     end
     
@@ -108,7 +108,7 @@ describe R::Vector do
     
     it "should retrieve values the same way as single square brackets" do
       vect = R.c(2.1, 4.2, 3.3, 5.4)
-      expect vect[[1]] == 2.1
+      expect(vect[[1]]).to eq 2.1
     end
     
   end
@@ -123,7 +123,7 @@ describe R::Vector do
     it "should subset assign with integer" do
       expect(@vect[2]).to eq 2
       @vect[2] = 1000
-      expect @vect[2] == 1000
+      expect(@vect[2]).to eq 1000
     end
     
     it "should subset assign to the elements given by another vector" do

data/specs/ruby_expression.spec.rb

@@ -0,0 +1,324 @@
+# -*- 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 'galaaz'
+
+#========================================================================================
+# class Expression in the R module extends Ruby's symbols, so that they can be used in
+# forming expressions of the form ':x + :y' or more complex than that.  Those
+# expressions will then be converted to R expressions when necessary.
+#========================================================================================
+
+describe Symbol do
+
+  #========================================================================================
+  context "Working with Ruby expressions"  do
+    
+    before(:each) do
+      R.len = 10
+      R.sd = 20
+      R.vec = R.c(1, 2, 3, 4)
+    end
+    
+    it "should convert a Ruby symbol into an R symbol with unary '+'" do
+      exp = +:len
+      expect(exp.class).to eq R::RSymbol
+      expect(exp.rclass).to eq "integer"
+      expect(exp.typeof).to eq "integer"
+      expect(exp.eval).to eq 10
+    end
+
+    it "should convert a Ruby symbol into an R symbol with 'expr'" do
+      exp = R.expr(:len)
+      expect(exp.class).to eq R::RSymbol
+      expect(exp.rclass).to eq "integer"
+      expect(exp.typeof).to eq "integer"
+      expect(exp.eval).to eq 10
+    end
+
+    it "should convert 'true' and 'false' to TRUE and FALSE in R" do
+      e = R.expr(true)
+      expect(e).to eq R.c(true)
+      e = R.expr(false)
+      expect(e).to eq R.c(false)
+    end
+
+    it "should allow binary operations with 'expressions'" do
+      e1 = +:len
+      e2 = e1 + 5
+      expect(e2.eval).to eq R.c(15)
+    end
+
+    it "should convert binary operations with Symbols to 'expressions'" do
+      e1 = :len + :sd
+      expect(e1.to_s).to eq "len + sd"
+      expect(e1.class).to eq R::Language
+      expect(e1.rclass).to eq "integer"
+      expect(e1.eval).to eq 30
+    end
+
+    it "should convert longer Ruby expressions to 'expression'" do
+      e1 = :len + :sd + 5
+      expect(e1.to_s).to eq "len + sd + 5L"
+      expect(e1.class).to eq R::Language
+      expect(e1.rclass).to eq "integer"
+      expect(e1.eval).to eq 35
+    end
+
+    it "should operate with all comparison operators" do
+      df = R.data__frame(a: (1..5), b: (5..1), c: R.c(5, 3, 1, 4, 1))
+      
+      e = :a > :b
+      expect(e.to_s).to eq "a > b"
+      expect(e.eval(df)).to eq R.c(false, false, false, true, true)
+      
+      e = :a.gt :b
+      expect(e.to_s).to eq "a > b"
+      expect(e.eval(df)).to eq R.c(false, false, false, true, true)
+      
+      e = :a >= :b
+      expect(e.to_s).to eq "a >= b"
+      expect(e.eval(df)).to eq R.c(false, false, true, true, true)
+      
+      e = :a.ge :b
+      expect(e.to_s).to eq "a >= b"
+      expect(e.eval(df)).to eq R.c(false, false, true, true, true)
+      
+      e = :a < :b
+      expect(e.to_s).to eq "a < b"
+      expect(e.eval(df)).to eq R.c(true, true, false, false, false)
+      
+      e = :a.lt :b
+      expect(e.to_s).to eq "a < b"
+      expect(e.eval(df)).to eq R.c(true, true, false, false, false)
+      
+      e = :a <= :b
+      expect(e.to_s).to eq "a <= b"
+      expect(e.eval(df)).to eq R.c(true, true, true, false, false)
+      
+      e = :a.le :b
+      expect(e.to_s).to eq "a <= b"
+      expect(e.eval(df)).to eq R.c(true, true, true, false, false)
+      
+      e = :a != :b
+      expect(e.to_s).to eq "a != b"
+      expect(e.eval(df)).to eq R.c(true, true, false, true, true)
+      
+      e = :a.ne :b
+      expect(e.to_s).to eq "a != b"
+      expect(e.eval(df)).to eq R.c(true, true, false, true, true)
+      
+      e = :a.eq :b
+      expect(e.to_s).to eq "a == b"
+      expect(e.eval(df)).to eq R.c(false, false, true, false, false)
+      
+    end
+
+    it "should inline r objects in 'expressions'" do
+      e1 = :len + :sd + 5 + R.c(1, 2, 3, 4)
+      expect(e1.to_s).to eq "len + sd + 5L + 1:4"
+      expect(e1.class).to eq R::Language
+      expect(e1.rclass).to eq "integer"
+      expect(e1.eval).to eq R.c(36, 37, 38, 39)
+      expect(e1.eval).not_to eq R.c(35, 37, 38, 39)
+    end
+
+    it "should create assignment expressions with method 'assign'" do
+      e = :x.assign :vec * 10
+      expect(e.to_s).to eq "x <- vec * 10L"
+      expect(e.eval).to eq R.c(10, 20, 30, 40)
+      expect(~:x).to eq R.c(10, 20, 30, 40)
+    end
+
+    it "should create quoted functions with 'E'" do
+      exp = E.sin(:vec)
+      expect(exp.to_s).to eq "sin(vec)"
+      expect(exp.eval.
+               all__equal R.c(0.841470984, 0.909297426, 0.141120008, -0.756802495)).to eq true
+    end
+
+    it "should require quoted expression to convert expression to string with 'as_string'" do
+      exp = E.expr(:len)
+      expect(exp.to_s).to eq "expr(len)"
+      expect(exp.as_string).to eq "len"
+      expect(exp.is__symbol).to eq true
+    end
+
+    it "should be possible to check if an expression is a call" do
+      exp = E.expr(E.sin(:x))
+      expect(exp.typeof).to eq "language"
+      expect(exp.typeof).not_to eq "matrix"
+      expect(exp.is__call).to eq true
+    end
+
+    it "should be able to subset a call as with lists" do
+      x = E.expr(E.read__table("important.csv", row__names: false))
+      expect(x.typeof).to eq "language"
+      expect(x.is__call).to eq true
+      expect(x[[1]].to_s).to eq "read.table"
+      expect(x[[2]]).to eq "important.csv"
+      expect(x[[3]]).to eq false
+      expect(x[["row.names"]]).to eq false
+      expect(x[["row.names"]]).not_to eq true
+      expect(x.length).to eq 3
+      # puts x.row__names  # does not work yet
+      # puts x.call_standardise # does not work yet
+      # x.header = true   # does not work yet
+    end
+
+    it "should allow constructing calls with 'call2'" do
+      e = R.call2("mean", x: E.expr(:x), na__rm: true)
+      expect(e.to_s).to eq "mean(x = x, na.rm = TRUE)"
+      
+      #> mean(x = x, na.rm = TRUE)
+      # e = call2(E.base::mean, x: E.expr(:x), na__rm: TRUE) # does not work yet
+      # puts e
+      #> base::mean(x = x, na.rm = TRUE)
+      
+      e = R.call2("<-", E.expr(:x), 10)
+      e.eval
+      expect(~:x).to eq 10
+    end
+
+    it "should allow executing a function with 'exec'" do
+      val = R.exec("mean", x: (1..10), na__rm: true, trim: 0.1)
+      expect(val).to eq 5.5
+
+      # using ruby arrays and * in place of !!!(list)
+      args = [x: (1..10), na__rm: true, trim: 0.1]
+      expect(R.exec("mean", *args)).to eq 5.5
+
+      # using ruby arrays and parameter in the function call. Note however
+      # that according to Ruby's rule, the array must come before the hash
+      # so R.exec("mean", x: (1..10), *params) is a syntax error
+      params = [na__rm: true, trim: 0.1]
+      expect(R.exec("mean", *params, x: (1..10))).to eq 5.5
+    end
+    
+  end
+
+  #========================================================================================
+  context "Expressions inside functions" do
+
+    it "should allow the use of expression in quoted functions" do
+      x = y = R.seq(-~:pi, ~:pi, length: 10)
+      df = R.data__frame(x: x, y: y)
+      
+      # quote the outer function
+      e = E.outer(:x, :y, lambda { |x, y| R.cos(y) / (1 + x**2) })
+
+      # evaluate the expression in the scope of a data frame
+      res = e.eval(df)
+      expect(res.rclass).to eq "matrix"
+      expect(res[1, 1].all__equal -0.091999668).to eq true
+    end
+
+    it "should be able to pass an expression to a 'subset'" do
+      df = R.data__frame(a: (1..5), b: (5..1), c: R.c(5, 3, 1, 4, 1))
+      
+      sub = R.subset(df, (:a.eq :b))
+      expect(sub.rclass).to eq "data.frame"
+      expect(sub[1, 1]).to eq 3
+      
+      sub = R.subset(df, :a >= 4)
+      expect(sub.nrow).to eq 2
+      expect(sub.ncol).to eq 3
+      expect(sub[1, 1]).to eq 4
+      expect(sub[1, 3]).to eq 4
+      expect(sub[2, 2]).to eq 1
+    end
+    
+  end
+
+  #========================================================================================
+  context "Evaluate data in the context of the ruby instance" do
+
+    before(:each) do
+      @df = R.data__frame(a: (1..5), b: (5..1), c: R.c(5, 3, 1, 4, 1))
+    end
+
+    it "should access columns of the data frame by name" do
+      # Note that we use {a} and not {:a}.  In the context of the @df
+      # object 'a' is a call to the method that returns column 'a'
+      expect(@df.instance_eval {a}).to eq R.c(1, 2, 3, 4, 5)
+      expect(@df.instance_eval {b}).to eq R.c(5, 4, 3, 2, 1)
+      expect(@df.instance_eval {c}).to eq R.c(5, 3, 1, 4, 1)
+    end
+    
+    it "should evaluate the expression in the given instance" do
+      # Ruby way of evaluation code in the scope of an object.
+      val = @df.instance_eval {a.eql 4}
+      expect(val).to eq R.c(false, false, false, true, false)
+
+      val = @df.instance_eval {a >= 3}
+      expect(val).to eq R.c(false, false, true, true, true)
+
+      val = @df.instance_eval {a.eql b}
+      expect(val).to eq R.c(false, false, true, false, false)
+    end
+    
+  end
+
+
+  #========================================================================================
+  context "Tidyverse evaluation" do
+
+    it "should allow passing expressions to ggplot" do
+      require 'ggplot'
+
+      # df is a Ruby symbol and ToothGrowth is an R dataframe.  But at this point
+      # there is no relationship between the two
+      df = :ToothGrowth
+      
+      # we now call a method on a Ruby symbol.  This will try to identify if this
+      # method exists in the R dataframe.  This is one of the columns of the R
+      # dataframe, so 'dose' is now an R expression
+      dose = df.dose
+      expect(dose.to_s).to eq "ToothGrowth[[\"dose\"]]"
+
+      # dose.assign is an R expression, equivalent to 'ToothGrowth[["dose"]] <-'
+      # an the whole expression becomes:
+      # 'ToothGrowth[["dose"]] <- as.factor(ToothGrowth[["dose"]])'
+      dose.assign dose.as__factor
+      
+      df2 = R.data__frame(
+        R.aggregate(df.len, by: R.list(dose), FUN: :mean),
+        R.aggregate(df.len, by: R.list(dose), FUN: :sd)[2]
+      )
+      
+      df2.names = R.c("dose", "len", "sd")
+
+      # pass the expressions ':len - :sd' and ':len + :sd' to the aes function
+      f = df2.ggplot(E.aes(x: :dose, y: :len, 
+                           ymin: :len - :sd,
+                           ymax: :len + :sd))
+
+      # create the graphics and saves it
+      R.png("specs/figures/dose_len.png")
+      puts f + R.geom_crossbar
+      R.dev__off
+    end
+
+  end
+
+end