galaaz 0.4.0

data/specs/r_language.spec.rb

@@ -0,0 +1,135 @@
+# -*- 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 == "cyl"
+    end
+    
+    it "should assign to an R symbol and retrieve from it" do
+      R.cyl = 10
+      expect ~:cyl == 10
+    end
+
+    it "should allow calling evaluate on the symbol" do
+      R.cyl = 10
+      expect R.eval(~:cyl) == 10
+    end
+
+  end
+  
+  #========================================================================================
+  context "When creating Calls" do
+
+    it "binary operators should apply to symbols" do
+      # this behaviour is a bit different from R's.  In R this would raise an error
+      # with cyl not found
+      expect (:cyl + 5).to_s == '.Primitive("+")(cyl, 5L)'
+    end
+
+    it "should properly coerce to language" do
+      expect (5 + 5).to_s == '.Primitive("+")(5L, cyl)'
+    end
+
+    # Formula objects are special and are very similar to quoted expressions, but
+    # they are not really quoted since trying to call R.typeof(<formula>) will
+    # evaluate the formula.  We add methods .typeof and .rclass in the Ruby class
+    it "formula have typeof and rclass" do
+      call = :cyl + 5
+      expect call.typeof == "language"
+      expect call.rclass == "call"
+    end
+
+    it "during calls creation, only symbols are unevaluated" do
+      # 5 * 10 evaluate to 50 in the call
+      expect(:cyl + 5 * 10).to_s == '.Primitive("+")(cyl, 50L)'
+      # define a variable x
+      x = 20
+      # x is not quoted in the expression
+      expect(:cyl + 5 * x).to_s == '.Primitive("+")(cyl, 100L)'
+    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) == 610
+    end
+
+    it "should eval an R function in the context of a list" do
+      R.x = 5
+      expect R.eval(:x + 10) == 15
+      ct = R.list(x: 20)
+      expect R.eval(:x + 10, ct) == 30
+    end
+    
+  end
+
+
+  #========================================================================================
+  context "When working with Formulas" do
+    
+    it "should create a RSymbol from a Ruby Symbol using +" do
+      sym = +:sym
+      expect sym.to_s == "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

@@ -0,0 +1,129 @@
+# -*- 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::List do
+
+  #----------------------------------------------------------------------------------------
+  context "When creating lists" do
+
+    it "should create an empty list" do
+      l = R.list
+      expect(l.length).to eq 0
+      expect(l.class).to eq R::List
+      expect(l.typeof).to eq "list"
+    end
+    
+    it "should return a list when R.list is called" do
+      l = R.list(1, 2)
+      expect(l.length).to eq 2
+      expect(l.class).to eq R::List
+      expect(l.typeof).to eq "list"
+    end
+    
+    it "should allow creating list of lists" do
+      l = R.list(1, 2, 3, R.list(4, 5, 6))
+      expect(l.length).to eq 4
+    end
+
+    it "should allow mixing different types of objects" do
+      l = R.list(R.c(1, 2, 3), R.c(1.0, 2.0, 3.0), R.list(a: 1, b: 2, c: 3),
+                 R.complex(real: R.rnorm(5), imag: R.rnorm(5)))
+    end
+
+    it "should create lists using sequences" do
+      x = R.list(a: (1..10), beta: R.exp(-3..3), logic: R.c(true, false, false, true))
+    end
+
+  end
+
+  #----------------------------------------------------------------------------------------
+  context "When subsetting a list" do
+    
+    before(:all) do
+      @l = R.list(1, 2, 3, R.list(4, 5, 6))
+    end
+
+    it "should subset with [] and positve integer.  Returns a list" do
+      expect(@l.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
+    end
+
+    it "should subset with [] and negative integer.  Returns a list" do
+      expect(@l[-4].identical(R.list(1, 2, 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
+    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
+      # dbk indexing to get a list
+      expect(@l[[4]].identical(R.list(4, 5, 6))).to eq true
+    end
+
+    it "can chain subsetting operations" do
+      # 1rst element of 4th vector is a list
+      expect(@l[[4]][1].identical(R.list(4))).to eq true
+      expect(@l[[4]][[1]]).to eq 4
+    end
+    
+    it "should subset with [[]] with multiple indexes" do
+      # Note that for a list or other recursive object, the index can be a vector
+      # and each element of the vector is applied in turn to the list, the
+      # selected component, the selected component of that component, and so on.
+      # The result is still a single element.
+      expect(@l[[4, 1]]).to eq 4
+    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
+        else
+          expect elmt.identical(R.list(4, 5, 6)) == true
+        end
+        i = i + 1
+      end
+    end
+
+    it "should subset with 'each_with_index'" do
+      @l.each_with_index do |elmt, i|
+        if (i < 4)
+          expect elmt == i
+        else
+          expect elmt.identical(R.list(4, 5, 6)) == true
+        end
+      end
+    end
+
+  end
+
+end

data/specs/r_list_apply.spec.rb

@@ -0,0 +1,99 @@
+# -*- 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'
+R.require 'stats'
+
+describe R::List do
+
+  context "The apply family of functions with lists" do
+
+    before(:all) do
+      @x = R.list(a: (1..10), beta: R.exp(-3..3), logic: R.c(true, false, false, true))
+      R.library("stats")
+      # Make @q the function R quantile
+      @q = ~:quantile
+    end
+    
+    it "should work with lapply and mean" do
+      # lapply applies a function to each element of a list or vector, returning a list.
+      # compute the list mean for each list element
+      mean = R.lapply(@x, "mean")
+      expect(mean.a).to eq 5.5
+      
+      # R.all__equal(x,y) is a utility to compare R objects x and y testing
+      # “near equality”. If they are different, comparison is still made to some extent,
+      # and a report of the differences is returned. Don't use R.all__equal directly
+      # in if expressions—either use isTRUE(all.equal(....)) or identical if appropriate.
+      # We cannot do mean.beta.all__equal in this case, since mean.beta is a Ruby float
+      # and method all__equal is not defined on floats.
+      expect(R.all__equal(mean.beta,
+                          4.5351252347,
+                          tolerance: (~:".Machine").double__eps ** 0.5)).to eq true
+
+      expect(mean.logic).to eq 0.5
+    end
+    
+    it "should allow using lapply with quantile" 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(R.all__equal(quant.beta["100,0000%"],
+                          20.08553692,
+                          tolerance: (~:".Machine").double__eps ** 0.5)).to eq true
+      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(R.all__equal(x.beta["75,00000%"],
+                          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
+    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)
+      sap = R.sapply(i39, ~:fivenum)
+      expect sap[1, 1] == 1
+      expect sap[5, 7] == 9
+    end
+  
+  end
+  
+end

data/specs/r_matrix.spec.rb

@@ -0,0 +1,83 @@
+# -*- 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 do
+
+  #----------------------------------------------------------------------------------------
+  context "Matrices" do
+
+    it "Should create a matrix by column" 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
+    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
+    end
+
+    it "Should add matrices" do
+      x = R.matrix(data: R.c(1, 2, 3, 4), nrow: 2, ncol: 2)
+      y = R.matrix(data: R.c(2, 4, 6, 8), nrow: 2, ncol: 2)
+      z = x + y
+      expect(z[1, 1] == 3).to eq true
+      expect(z[2, 2] == 12).to eq true
+    end
+    
+    it "Should subtract matrices" do
+      x = R.matrix(data: R.c(1, 2, 3, 4), nrow: 2, ncol: 2)
+      y = R.matrix(data: R.c(2, 4, 6, 8), nrow: 2, ncol: 2)
+      z = y - x
+      expect(z[1, 1] == 1).to eq true
+      expect(z[2, 2] == 4).to eq true
+    end
+
+    it "should multiply by a scalar" do
+      y = R.matrix(data: R.c(2, 4, 6, 8), nrow: 2, ncol: 2)
+      z = y * 10
+      expect(z[1, 1] == 20).to eq true
+      expect(z[2, 1] == 40).to eq true
+    end
+
+    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
+    end
+
+    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
+    end      
+
+  end
+
+end

data/specs/r_vector_creation.spec.rb

@@ -0,0 +1,99 @@
+# -*- 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::Vector do
+  
+  context "When creating vectors" do
+    
+    it "should create logical Vectors" do
+      log_vect = R.c(true, false, true, true)
+      expect(log_vect.length).to eq 4
+      expect(log_vect.class).to eq R::Vector
+      expect(log_vect.typeof).to eq "logical"
+      expect(log_vect.mode).to eq "logical"
+      expect(log_vect.storage__mode).to eq "logical"
+    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
+      # number 1L is an integer
+      int_vect = R.c(1, 2)
+      expect(int_vect.length).to eq 2
+      expect(int_vect.class).to eq R::Vector
+      expect(int_vect.typeof).to eq "integer"
+      expect(int_vect.mode).to eq "numeric"
+      expect(int_vect.storage__mode).to eq "integer"
+    end
+    
+    it "should create double Vectors" do
+      float_vect = R.c(3.0, 4, 5)
+      expect(float_vect.length).to eq 3
+      expect(float_vect.class).to eq R::Vector
+      expect(float_vect.typeof).to eq "double"
+      expect(float_vect.mode).to eq "numeric"
+      expect(float_vect.storage__mode).to eq "double"
+    end
+    
+    it "should create character Vectors" do
+      # Here the vector has 3 elements
+      str_vect = R.c("Hello", "beautiful", "world!")
+      expect(str_vect.length).to eq 3
+      expect(str_vect.class).to eq R::Vector
+      expect(str_vect.typeof).to eq "character"
+      expect(str_vect.mode).to eq "character"
+      expect(str_vect.storage__mode).to eq "character"
+    end
+    
+    it "should create a complex Vector" do
+      complex_vec = R.complex(real: R.rnorm(100), imag: R.rnorm(100))
+      expect(complex_vec.length).to eq 100
+      expect(complex_vec.typeof).to eq "complex"
+      expect(complex_vec.mode).to eq "complex"
+      expect(complex_vec.storage__mode).to eq "complex"
+    end
+    
+    it "should allow creation of vectors of vectors" do
+      vect = R.c(1, 2, 3, R.c(4, 5, 6))
+      expect(vect.length).to eq 6
+      expect(vect.class).to eq R::Vector
+      expect(vect[4]).to eq 4
+    end
+    
+    it "should create vectors with the use of other R functions" do
+      # R.rep repeats the given vector
+      vec2 = R.rep(R.c("A", "B", "C"), 3)
+      # vec2.pp
+      # expect(vec2.identical(R.c("A", "B", "C", "A", "B", "C", "A", "B", "C"))).to eq true
+      
+      # R.table calculates the frequencies of elements
+      vec3 = R.c("A", "B", "C", "A", "A", "A", "A", "B", "B")
+      table = R.table(vec3)
+      # expect(R.c(5, 3, 1).identical table).to eq true
+    end
+    
+  end
+  
+end
+