galaaz 0.4.5 → 0.4.6

data/specs/r_formula.spec.rb

@@ -49,7 +49,7 @@ describe R::Language do
       expect(rform.rclass).to eq 'formula'
     end
 
-    it "should create a formula with '.' by using the ':all' keyword in the rhs" do
+    it "should create a formula with '.' in the rhs" do
       formula = R.formula("supp ~ .")
       expect(formula.to_s.lines.first.chomp).to eq "supp ~ ."
       
@@ -77,7 +77,7 @@ describe R::Language do
       expect(formula.to_s.lines.first.chomp).to eq "~supp"
       
       formula = :all.til :supp
-      expect(formula.to_s.lines.first.chomp).to eq " ~ supp"
+      expect(formula.to_s.lines.first.chomp).to eq "~supp"
       expect(formula.rclass).to eq "formula"
       expect(formula.typeof).to eq "language"
     end

data/specs/r_language.spec.rb

@@ -0,0 +1,112 @@
+# -*- 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'
+
+describe R::Language do
+
+  #========================================================================================
+  context "Working with symbols"  do
+
+    it "should convert a Ruby Symbol to an R Symbol with '+'" do
+      a = +:cyl
+      expect(a.is_a? R::RSymbol).to eq true
+      expect(a.to_s).to eq "cyl"
+    end
+    
+    it "should assign to an R symbol and retrieve from it" do
+      R.cyl = 10
+      expect(~:cyl).to eq 10
+    end
+
+    it "should allow calling evaluate on the symbol" do
+      R.cyl = 10
+      expect(R.eval(~:cyl)).to eq 10
+    end
+
+  end
+  
+  #========================================================================================
+
+  context "Executing R expressions" do
+
+    it "should eval an R expression in the context of a list" do
+      ct = R.list(a: 10, b: 20, c: 30)
+      exp = :a + :b * :c
+      expect(R.eval(exp, ct)).to eq 610
+    end
+
+    it "should eval an R function in the context of a list" do
+      R.x = 5
+      expect(R.eval(:x + 10)).to eq 15
+      ct = R.list(x: 20)
+      expect(R.eval(:x + 10, ct)).to eq 30
+    end
+    
+  end
+
+
+  #========================================================================================
+  context "When working with Formulas" do
+    # When working with formulas, Ruby symbols such be preceded by the '+' function.
+    # If you want to make a formula such as 'a ~ b' in R, then this should be written
+    # as '+:a =~ +:b'.  When, in an binary operation, the Ruby symbol will be converted
+    # to an R symbol.  The formula '+:a =~ +:b', can also be written as '+:a =~ :b'.  Be
+    # careful, however, when using the Ruby symbol without the '+' since in a more complex
+    # formula, Ruby's precedence rules might not result in what is expected.  As an example
+    # '+:a =~ :b * +:c' crashes with the error 'b' not found, since '*' has precedence over
+    # '=~' and this is equivalent to '+:a =~ (:b * +:c)' and there is no sense in
+    # multiplying a Ruby symbol. The recomendation is to always use the '+' function
+    # before the Ruby symbol.
+    
+    it "should create a RSymbol from a Ruby Symbol using +" do
+      sym = +:sym
+      expect(sym.to_s).to eq "sym"
+    end
+
+=begin
+    
+    it "should create a formula without the lhs" do
+      pending "formulas need to be reimplemented"
+      formula = ~(:cyl + :exp)
+      expect formula.to_s == '~.Primitive("+")(cyl, exp)'
+      expect formula.typeof == 'language'
+      expect formula.rclass == 'formula'
+    end
+    
+    it "should create formulas with the '=~' operator" do
+      formula = (:cyl =~ :exp)
+      expect(formula.to_s) == '.Primitive("~")(cyl, exp)'
+      expect formula.typeof == 'language'
+      expect formula.rclass == 'formula'
+      
+      formula2 = (:cyl =~ :exp + :exp2 - :exp3)
+      expect formula2.to_s == 'cyl ~ .Primitive("-")(.Primitive("+")(exp, exp2), exp3)'
+      expect formula.typeof == 'language'
+      expect formula.rclass == 'formula'
+    end
+=end
+    
+  end
+
+end

data/specs/r_list.spec.rb

@@ -59,31 +59,103 @@ describe R::List do
   end
 
   #----------------------------------------------------------------------------------------
-  context "When subsetting a list" do
+  context "When subsetting a list with '<<' (starts at 0)" do
     
-    before(:all) do
-      @l = R.list(1, 2, 3, R.list(4, 5, 6))
+    before(:each) do
+      @l = R.list(1, a: 2, b: 3, c: R.list(4, 5, 6))
+    end
+
+    it "should return the 'native' (Ruby) element of the list at numeric index" do
+      expect(@l >> 0).to eq 1
+      expect(@l >> 1).to eq 2
+      expect(@l >> 2).to eq 3
+    end
+
+    it "should return the 'native' (Ruby) element of the list at named index" do
+      expect(@l['a'] >> 0).to eq 2
+      expect(@l[['a']] >> 0).to eq 2
+      expect(@l['b'] >> 0).to eq 3
+    end
+
+    it "should raise an exception (IndexError) if index out of bounds" do
+      expect { @l >> 4 }.to raise_error(IndexError)
+    end
+
+    it "should raise an exception (Argument error) if indexed element is not a vector" do
+      expect { @l >> 3 }.to raise_error(ArgumentError)
+    end
+
+    it "should return nil if named index does not exists" do
+      expect(@l['k'] >> 0).to eq nil
+    end
+
+  end
+  
+  #----------------------------------------------------------------------------------------
+  context "When subsetting a list with '['" do
+    
+    before(:each) do
+      # the 'all' keywork means 'empty', so this is a list of the form
+      # list(a = 1, b = 2, list(c = 3))... note that the 3rd element of the
+      # list has no name.  In Ruby, doing R.list(a: 1, b: 2, R.list(c: 3)) is
+      # a syntax error, since named parameters need to come at the end of the
+      # parameter list.  To fix that we do: R.list(a: 1, b: 2, all: R.list(c: 3))
+      # However, note that we cannot have two identical named parameters in a
+      # function call, as Ruby will detect it as an error and pass only one of
+      # the named parameters and not both.
+      
+      # The following list has only 3 elements and not 4 since the 'all' parameter
+      # was used twice.  This is a limitation of Ruby
+      @l = R.list(a: 1, b: 2, all: 3, all: R.list(i: 4, j: 5, all: 6))
+
+      # This list has 4 elements.
+      @l1 = R.list(a: 1, b: 2, all: 3, d: R.list(i: 4, j: 5, all: 6))
+
+      # if possible, change the order of the list with unamed parameters first.
+      # Although clearly those lists are different, named parameters can still
+      # be recovered by name
+      @l2 = R.list(3, R.list(6, i:4, j: 5), a: 1, b: 2)
+    end
+
+    it "should allow accessing parameters named with 'all' by position" do
+      expect(@l.length).to eq 3
+      # Note that the first 'all' parameter was droped.  Don't know if this
+      # is implementation dependend, but in TruffleRuby that's the way it is
+      # (at least for now).
+      expect(@l[[3]]).to eq R.list(i:4, j: 5, all: 6)
     end
 
     it "should subset with [] and positve integer.  Returns a list" do
-      expect(@l.length).to eq 4
+      expect(@l1.length).to eq 4
       # Subsetting a list with [] returns a list 
-      expect(@l[1].identical(R.list(1))).to eq true
-      # the 4th element of the list is a list of a list
-      expect(@l[4].identical(R.list(R.list(4, 5, 6)))).to eq true
+      expect(@l1[1]).to eq R.list(a: 1)
+      expect(@l1[1] == R.c(a: 1)).to eq false
+      expect(@l1[1]).not_to eq R.c(a: 1)
+      
+      # the 4th element of the list is another list
+      expect(@l1[4]).to eq R.list(d: R.list(i: 4, j: 5, all: 6))
     end
 
     it "should subset with [] and negative integer.  Returns a list" do
-      expect(@l[-4].identical(R.list(1, 2, 3))).to eq true
+      expect(@l1[-4] == R.list(a: 1, b: 2, all: 3)).to eq true
     end
 
     it "should subset with [] and a vector as index" do
-      expect(@l[R.c(4, 1)].identical(R.list(R.list(4, 5, 6), 1))).to eq true
+      expect(@l1[R.c(4, 1)] == R.list(d: R.list(i: 4, j: 5, all: 6), a: 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
+    
+  end
+
+  #----------------------------------------------------------------------------------------
+  context "When subsetting a list with '[['" do
+    
+    before(:each) do
+      @l = R.list(1, 2, 3, R.list(4, 5, 6))
+    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
@@ -106,13 +178,40 @@ describe R::List do
       expect(@l[[4, 1]]).to eq 4
     end
 
+  end
+
+  #----------------------------------------------------------------------------------------
+  context "When subsetting a list with '.'" do
+
+    before(:each) do
+      # This list has 4 elements.
+      @l1 = R.list(a: 1, b: 2, all: 3, d: R.list(i: 4, j: 5, all: 6))
+    end
+
+    it "should access named elements with '.<name>'" do
+      # access with '.' is equivalent to access with '[[
+      expect(@l1.a == R.c(1)).to eq true
+      expect(@l1.a).to eq 1
+      expect(@l1.b).to eq 2
+      expect(@l1.d == R.list(i: 4, j: 5, all: 6)).to eq true
+    end
+    
+  end
+  
+  #----------------------------------------------------------------------------------------
+  context "When subsetting a list with 'each' and 'each_with_index'" do
+
+    before(:each) do
+      @l = R.list(1, 2, 3, R.list(4, 5, 6))
+    end
+
     it "should subset with 'each' returning every element as if subsetting with '[['" do
       i = 1
       @l.each do |elmt|
         if (i < 4)
-          expect elmt == i
+          expect(elmt).to eq i
         else
-          expect elmt.identical(R.list(4, 5, 6)) == true
+          expect(elmt.identical(R.list(4, 5, 6))).to eq true
         end
         i = i + 1
       end
@@ -121,13 +220,74 @@ describe R::List do
     it "should subset with 'each_with_index'" do
       @l.each_with_index do |elmt, i|
         if (i < 4)
-          expect elmt == i
+          expect(elmt).to eq i
         else
-          expect elmt.identical(R.list(4, 5, 6)) == true
+          expect(elmt.identical(R.list(4, 5, 6))).to eq true
         end
       end
     end
 
   end
 
+  #----------------------------------------------------------------------------------------
+  context "When modifying a list" do
+
+    before(:each) do
+      @l = R.list(a: 1, b: 2, c: 3, d: R.list(i: 4, j: 5, k: 6))
+    end
+
+    it "should be possible to modify a list by index" do
+      @l[[1]] = 10
+      expect(@l.length).to eq 4
+      expect(@l[[1]]).to eq 10
+    end
+
+    it "should be possible to modify a list by element name in '[[" do
+      @l[['a']] = 10
+      expect(@l[['a']]).to eq 10
+      expect(@l.a).to eq 10
+    end
+    
+    it "should be possible to modify a list by element name with '.'" do
+      @l.b = 20
+      expect(@l[['b']]).to eq 20
+      expect(@l.b).to eq 20
+    end
+
+    it "should be possible to add an element to the list with '[[" do
+      @l[['married']] = true
+      expect(@l.length).to eq 5
+      expect(@l[['married']]).to eq true
+      expect(@l.married).to eq true
+    end
+
+    it "should be possible to add an element to the list with '.'" do
+      @l.married = true
+      expect(@l.length).to eq 5
+      expect(@l[['married']]).to eq true
+      expect(@l.married).to eq true
+      
+      @l.number = 5.345
+      @l.lst = R.list(100, 200)
+      @l.vec = R.c(500, 600)
+
+      expect(@l.length).to eq 8
+      expect(@l.vec).to eq R.c(500, 600)
+      expect(@l.vec).not_to eq R.c(1000)
+    end
+
+    it "should be possible to remove an element from a list by assigning 'nil' to it" do
+      @l[['d']] = nil
+      expect(@l.length).to eq 3
+      expect(@l).to eq R.list(a: 1, b: 2, c: 3)
+    end
+    
+    it "should be possible to remove an element from a list by assigning 'nil' with '.'" do
+      @l.d = nil
+      expect(@l.length).to eq 3
+      expect(@l).to eq R.list(a: 1, b: 2, c: 3)
+    end
+
+  end
+  
 end

data/specs/r_list_apply.spec.rb

@@ -58,29 +58,36 @@ describe R::List do
       # lapply applies a function to each element of a list or vector, returning a list.
       # median and quartiles for each list element
       quant = R.lapply(@x, @q)
-      expect(quant.a[1]).to eq 1
-      expect(quant.a["50,00000%"]).to eq 5.50
+      expect(quant.a[1] == R.c('0%': 1.0)).to eq true
+      expect(quant.a[1]).to eq R.c('0%': 1.0)
+      expect(quant.a[[1]]).to eq 1.0
+             
+      expect(quant.a[["50%"]]).to eq 5.50
+      expect(quant.a['50%']).to eq R.c('50%': 5.50)
       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
+      expect(quant.logic[[2]]).to eq 0.0
     end
     
     it "should allow using method lapply with quantile" 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(x.a[[1]]).to eq 3.25
+      expect(x.a[["50%"]]).to eq 5.50
       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
+      expect(x.logic[[2]]).to eq 0.5
     end
 
     it "should allow using sapply and quantile" do
+      # sapply will return a matrix
       quant = R.sapply(@x, @q)
       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
+      
+      expect(quant[:all, 'a']).to eq R.c('0%': 1, '25%': 3.25, '50%': 5.50, '75%': 7.75, '100%': 10)
+      
+      expect(quant[3, 'beta']).to eq 1.0
     end
     
     it "should sapply to a sequence" do
@@ -90,8 +97,8 @@ describe R::List do
       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]).to eq 1
-      expect(sap[5, 7]).to eq 9
+      expect(sap[1, 1]).to eq 1.0
+      expect(sap[5, 7]).to eq 9.0
     end
   
   end

data/specs/r_matrix.spec.rb

@@ -32,14 +32,14 @@ describe R::Matrix do
       x = R.matrix(data: R.c(1, 2, 3, 4), nrow: 2, ncol: 2)
       expect(x[1, 1] == 1).to eq true
       expect(x[1, 2] == 3).to eq true
-      expect(x.dim == 2).to eq true
+      expect(x.dim == R.c(2, 2)).to eq true
     end
     
     it "Should create a matrix by row" do
       x = R.matrix(data: R.c(1, 2, 3, 4), nrow: 2, ncol: 2, byrow: true)
       expect(x[1, 1] == 1).to eq true
       expect(x[1, 2] == 2).to eq true
-      expect(x.dim == 2).to eq true
+      expect(x.dim == R.c(2, 2)).to eq true
     end
 
     it "Should add matrices" do
@@ -68,7 +68,7 @@ describe R::Matrix do
     it "should divide a scalar by a matrix" do
       y = R.matrix(data: R.c(2, 4, 6, 8), nrow: 2, ncol: 2)
       z = 10/y
-      expect(z == R.c(10/2, 10/4, 10/6, 10/8)).to eq true
+      expect(z).to eq R.matrix(data: R.c(10/2.0, 10/4.0, 10/6.0, 10/8.0), nrow: 2, ncol: 2)
     end
 
     it "should apply a function to all elements of the matrix: ex: sqrt" do

data/specs/r_vector_operators.spec.rb

@@ -69,9 +69,11 @@ describe R::Vector do
 
      it "should operate with Numeric first" do
        res = 10 + @vec1
-       expect(res == R.c(13, 15.7, 20, 22)).to eq true
+       expect(res.identical(R.c(13, 15.7, 20, 22))).to eq true
+       
        res = 10 - @vec1
-       expect(res == R.c(7, 4.3, 0, -1)).to eq true
+       expect(res.identical(R.c(7, 4.3, 0, -2))).to eq true
+       
        res = 10 / @vec1
        expect(res.all__equal R.c(3.333333333, 1.754385964, 1, 0.833333333)).to eq true
      end
@@ -135,17 +137,21 @@ describe R::Vector do
        # Use the '<<' operator to retrieve an element of the R::Vector as a Numeric
        # object
        expect(@vec1[1].is_a? R::Vector).to eq true
-       expect((@vec1 << 0).is_a? Numeric).to eq true
+       expect((@vec1 >> 0).is_a? Numeric).to eq true
 
        # Note, however, that indexing starts at 0
-       expect((@vec1 << 0)).to eq 3
-       expect((@vec1 << 2)).to eq 10
+       expect((@vec1 >> 0)).to eq 3
+       expect((@vec1 >> 2)).to eq 10
+     end
+
+     it "Should raise an exeption if '<<' out of bounds" do
+       expect { @vec1 >> 5 }.to raise_error(IndexError)
      end
 
      it "should treat R::Vector as an Enumerable" do
        # each 'value' is an R::Vector, with only 1 element.  In order to use Ruby 'sum'
-       # we need to extract the value as a Ruby Numeric with << 1
-       expect(@vec1.sum { |value| value << 0 }).to eq 30.7
+       # we need to extract the value as a Ruby Numeric with >> 1
+       expect(@vec1.sum { |value| value >> 0 }).to eq 30.7
      end
 
      it "should implement 'pop' to extract the first element of an R::Vector" do