galaaz 0.5.0 → 2.0.0

data/specs/r_formula.spec.rb

@@ -1,232 +0,0 @@
-# -*- 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.install_and_loads('ISLR', 'MASS')
-
-describe R::Language do
-
-  #========================================================================================
-  context "When working with Formulas" do
-    
-    it "should create formulas with the 'formula' function" do
-      formula = R.formula("log(y) ~ a + log(x)")
-      # formulas also capture their environment.  When printing the
-      # formula, two lines are printed: the first one with the formula
-      # and the second one with the environmnet. We are keeping only the
-      # first line for comparing with the expected formula
-      expect(formula.to_s.lines.first.chomp).to eq "log(y) ~ a + log(x)"
-    end
-
-    it "should create formulas with the '.til' function" do
-      formula = R.formula("cyl ~ exp")
-      expect(formula.to_s.lines.first.chomp).to eq "cyl ~ exp"
-      
-      formula = (:cyl.til :exp)
-      expect(formula.to_s.lines.first.chomp).to eq "cyl ~ exp"
-      rform = R.identity(formula)
-      expect(rform.typeof).to eq 'language'
-      expect(rform.rclass).to eq 'formula'
-    end
-
-    it "should create a formula with '.' in the rhs" do
-      formula = R.formula("supp ~ .")
-      expect(formula.to_s.lines.first.chomp).to eq "supp ~ ."
-      
-      # this formula is interpreted as 'supp ~ .' In this statement formula
-      # is an R::Expression which has infix and prefix notation
-      formula = :supp.til :__
-      expect(formula.to_s.lines.first.chomp).to eq "supp ~ ."
-      expect(formula.rclass).to eq "formula"
-      expect(formula.typeof).to eq "language"
-    end
-    
-    it "should create a formula with '.' by using the ':__' keyword in the lhs" do
-      formula = R.formula(". ~ supp")
-      expect(formula.to_s.lines.first.chomp).to eq ". ~ supp"
-
-      # this formula is interpreted as '. ~ supp'
-      formula = :__.til :supp
-      expect(formula.to_s.lines.first.chomp).to eq ". ~ supp"
-      expect(formula.rclass).to eq "formula"
-      expect(formula.typeof).to eq "language"
-    end
-
-    it "should create a formula starting with '~' with the ':all' symbol in the lhs" do
-      formula = R.formula("~ supp")
-      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.rclass).to eq "formula"
-      expect(formula.typeof).to eq "language"
-    end
-
-    it "should allow formulas with conditional" do
-      formula = R.formula("Sepal.Width ~ Petal.Width | Species")
-      expect(formula.to_s.lines.first.chomp).to eq "Sepal.Width ~ Petal.Width | Species"
-      
-      formula = :Sepal__Width.til :Petal__Width | :Species
-      expect(formula.to_s.lines.first.chomp).to eq "Sepal.Width ~ Petal.Width | Species"
-    end
-
-    it "should allow creating formulas with functions in the lhs" do
-      formula = E.log(:y).til :a + E.log(:x)
-      expect(formula.to_s.lines.first.chomp).to eq "log(y) ~ a + log(x)"
-    end
-    
-  end
-
-  #========================================================================================
-  context "Formula operators" do
-
-    it "should add multiple independent variables to a formula with '+'" do
-      # Use multiple independent variables
-      formula = :y.til :x1 + :x2
-      expect(formula.to_s.lines.first.chomp).to eq "y ~ x1 + x2"
-    end
-
-    it "should ignore objects in an analysis with '-'" do
-      # Ignore objects in an analysis
-      formula = :y.til :x1 - :x2
-      expect(formula.to_s.lines.first.chomp).to eq "y ~ x1 - x2"
-    end
-    
-    it "should create interaction between objects with '*'" do
-      # Ignore objects in an analysis
-      formula = :y.til :x * :x2
-      expect(formula.to_s.lines.first.chomp).to eq "y ~ x * x2"
-
-      # Set seed
-      R.set__seed(123)
-      
-      # Data
-      R.x = R.rnorm(5)
-      R.x2 = R.rnorm(5)
-      R.y = R.rnorm(5)
-      
-      # Model frame
-      model = R.model__frame(formula, data: R.data__frame(x: :x, y: :y, x2: :x2))
-      expect(model[1, 1].all__equal(1.22408179743946)).to eq true
-      expect(model[1, 3].all__equal(1.71506498688328)).to eq true
-      expect(model[3, 2].all__equal(1.55870831414912)).to eq true
-      expect(model[5, 1].all__equal(-0.555841134754075)).to eq true
-    end
-
-    it "should allow creating formulas with interaction between variables with 'inter'" do
-      formula = :y.til :x + :x2 + (:x.inter :x2)
-      expect(formula.to_s.lines.first.chomp).to eq "y ~ x + x2 + x:x2"
-
-      # Set seed
-      R.set__seed(123)
-      
-      # Data
-      R.x = R.rnorm(5)
-      R.x2 = R.rnorm(5)
-      R.y = R.rnorm(5)
-      
-      # Model frame
-      model = R.model__frame(formula, data: R.data__frame(x: :x, y: :y, x2: :x2))
-      expect(model[1, 1].all__equal(1.22408179743946)).to eq true
-      expect(model[1, 3].all__equal(1.71506498688328)).to eq true
-      expect(model[3, 2].all__equal(1.55870831414912)).to eq true
-      expect(model[5, 1].all__equal(-0.555841134754075)).to eq true
-    end
-
-    it "should allow creating formulas with interaction with ':in'" do
-      # note that '_' is a method with two arguments ':in' and ':a' and
-      # that it is necessary to put the whole expression in parenthesis or
-      # add parenthesis on the arguments
-      formula = :y.til :a + (:b._ :in, :a)
-      expect(formula.to_s.lines.first.chomp).to eq "y ~ a + b %in% a"
-    end
-
-  end
-
-  #========================================================================================
-  context "When modeling with formulas - Simple linear regression" do
-
-    before(:each) do
-      @boston_lm = R.lm((:medv.til :lstat), data: :Boston)
-    end
-
-    it "should obtain data from the model" do
-      expect(@boston_lm.coefficients[[1]].all__equal(34.5538408)).to eq true
-      expect(@boston_lm.coefficients[[2]].all__equal(-0.950049353)).to eq true
-
-      expect(@boston_lm.names[[1]]).to eq "coefficients"
-      expect(@boston_lm.names[[2]]).to eq "residuals"
-      expect(@boston_lm.names[[12]]).to eq "model"
-    end
-
-    it "should do predictions (confidence) based on the model" do
-      # predict the confidence interval
-      conf = R.predict(@boston_lm, R.data__frame(lstat: (R.c(5, 10, 15))),
-                       interval: "confidence")
-      expect(conf[1, :all][['fit']].all__equal(29.8035941)).to eq true
-      expect(conf[2, :all][['lwr']].all__equal(24.4741320)).to eq true
-      expect(conf[3, :all][['upr']].all__equal(20.8746129)).to eq true
-    end
-
-    it "should do prediction (prediction) based on the model" do
-      pred = R.predict(@boston_lm, R.data__frame(lstat: (R.c(5, 10, 15))),
-                       interval: "prediction")
-      expect(pred[1, :all][['fit']].all__equal(29.8035941)).to eq true
-      expect(pred[2, :all][['lwr']].all__equal(12.82762634)).to eq true
-      expect(pred[3, :all][['upr']].all__equal(32.5284590)).to eq true
-    end
-
-  end
-
-  #========================================================================================
-  context "Multiple linear regression" do
-
-    it "should do multiple linear regression" do
-      # Multiple linear regression from ISLR book.  Chapter 3 Lab, pg 113
-      lm_fit = R.lm((:medv.til :lstat + :age), data: :Boston)
-      
-      # Intercept
-      expect(lm_fit.coefficients[[1]].all__equal(33.2227605317)).to eq true
-      # lstat
-      expect(lm_fit.coefficients[[2]].all__equal(-1.0320685641)).to eq true
-      expect(lm_fit.coefficients[['lstat']].all__equal(-1.0320685641)).to eq true
-      # age
-      expect(lm_fit.coefficients[[3]].all__equal(0.0345443385)).to eq true
-    end
-
-    it "should do multiple linear regression with polynomials" do
-      lm_fit5 = R.lm((:medv.til E.poly(:lstat, 5)), data: :Boston)
-
-      # Intercept
-      expect(lm_fit5.coefficients[[1]].all__equal(22.53280632411)).to eq true
-      # Poly 1
-      expect(lm_fit5.coefficients[[2]].all__equal(-152.4595487225)).to eq true
-      # Poly 3
-      expect(lm_fit5.coefficients[[4]].all__equal(-27.0510978864097)).to eq true
-      # Poly 5
-      expect(lm_fit5.coefficients[[6]].all__equal(-19.2524177100554)).to eq true
-    end
-    
-  end
-  
-end

data/specs/r_language.spec.rb

@@ -1,112 +0,0 @@
-# -*- 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

@@ -1,293 +0,0 @@
-# -*- 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 with '>>' (starts at 0)" do
-    
-    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(@l1.length).to eq 4
-      # Subsetting a list with [] returns a list 
-      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(@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(@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
-      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 a vector" 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[[R.c(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).to eq i
-        else
-          expect(elmt.identical(R.list(4, 5, 6))).to eq 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).to eq i
-        else
-          expect(elmt.identical(R.list(4, 5, 6))).to eq true
-        end
-      end
-    end
-
-  end
-
-  #----------------------------------------------------------------------------------------
-  context "When assigning to a list subset" 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