scicom 0.2.0-java

data/lib/scicom.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2013 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 'mdarray'
+
+require_relative 'env'
+require_relative 'JRubyR/renjin'
+
+

data/test/baseball.csv

@@ -0,0 +1 @@
+Team,League,Year,RS,RA,W,OBP,SLG,BA,Playoffs,RankSeason,RankPlayoffs,G,OOBP,OSLG

data/test/env.rb

@@ -0,0 +1,7 @@
+# set to true if development environment.  Set to false before publishing
+$DVLP = true
+
+if $DVLP == true
+  require_relative '../config.rb'
+end
+

data/test/test_R_interface.rb

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Copyright © 2013 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 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require 'env'
+require 'scicom'
+
+class SciComTest < Test::Unit::TestCase
+
+  context "R environment" do
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    # Creating a variable in R and assign a value to it.  In this case assign the NULL 
+    # value.  There are two ways of assign variables in R, through method assign or with
+    # the '=' method.  To retrieve an R variable just acess it in the R namespace.
+    #--------------------------------------------------------------------------------------
+
+    should "use R.eval to evaluate an R expression" do
+
+      # The NULL value
+
+      # variable null is NULL.  Variable 'null' exists in the R namespace and can be 
+      # access normally in a call to 'eval'
+      R.eval("null = NULL")
+      R.eval("print(null)")
+
+      # Basic integration with R can always be done by calling eval and passing it a valid
+      # R expression.
+      R.eval("r.i = 10L")
+      R.eval("print(r.i)")
+
+      R.eval("vec = c(10, 20, 30, 40, 50)")
+      R.eval("print(vec)")
+      R.eval("print(vec[1])")
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "use assign and pull to set and get data from R" do
+
+      # Using method assign, to assign NULL to variable 'null' in R namespace.
+      R.assign("null", nil)
+      assert_equal(nil, R.null)
+
+      # Variable 'res' is available only in the Ruby namespace and not in the R namespace.
+      # a NULL object in R is converted to nil in Ruby.
+      res = R.pull("null")
+      assert_equal(nil, res)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "assing value to R variables as Ruby attributes" do
+
+      # Assign a value to an R variable, 'n2'.  
+      R.n2 = nil
+      assert_equal(nil, R.n2)
+
+      # One can access variables created in R namespace by using R.<var>.  Variable in
+      # R that have a '.' such as 'r.i3' need to have the '.' substituted by '__'
+      R.eval("r.i3 = 10.235")
+      R.r__i3.pp
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "accept here docs " do
+
+      R.eval <<EOF
+        r.i2 = 10L
+        print(r.i2)  
+EOF
+
+      # Variables created in Ruby can be accessed in an eval clause:
+      val = "10L"
+      R.eval <<EOF
+        r.i3 = #{val}
+        print(r.i3)
+EOF
+
+      R.eval <<EOF
+
+        # This dataset comes from Baseball-Reference.com.
+        baseball = read.csv("baseball.csv")
+        # str is bogus on Renjin
+        # str(data)
+
+        # prints the index of maximum and minimum years for the dataset
+        print(which.max(baseball$Year))
+        print(which.min(baseball$Year))
+
+        # Lets look at the data available for Momeyball.
+        moneyball = subset(baseball, Year < 2002)
+
+        # Let's see if we can predict the number of wins, by lookin at
+        # runs allowed (RA) and runs scored (RS).  RD is the runs difference.
+        # We are making a linear model from predicting wins (W) based on RD
+        moneyball$RD = moneyball$RS - moneyball$RA
+        WinsReg = lm(W ~ RD, data=moneyball)
+        print(summary(WinsReg))
+EOF
+
+    end
+
+  end
+
+end
+
+# Result of calling print(summary(WinsRed)):
+#
+# Call:
+# lm(data = moneyball, formula = W ~ RD)
+#
+# Residuals:
+#    Min      1Q  Median      3Q     Max
+# -14,266  -2,651   0,123   2,936  11,657
+#
+# Coefficients:
+#            Estimate   Std. Error t value    Pr(>|t|)             
+# (Intercept) 80,881     0,131      616,675    <0         ***       
+#          RD 0,106      0,001       81,554    <0         ***       
+# ---
+# Signif. codes:  0 '***' 0,001 '**' 0,01 '*' 0,05 '.' 0,1 ' ' 1 
+#
+# Residual standard error: 3,939 on 900 degrees of freedom
+# Multiple R-squared: 0,8808,	Adjusted R-squared: 0,8807 
+# F-statistic: 6.650,9926 on 1 and 900 DF,  p-value: < 0 

data/test/test_array.rb

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Copyright © 2013 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 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require 'env'
+require 'scicom'
+
+class SciComTest < Test::Unit::TestCase
+
+  context "R environment" do
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
+      
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "create array with the creator function" do
+
+      # You have two different options for constructing matrices or arrays. Either you use 
+      # the creator functions matrix() and array(), or you simply change the dimensions 
+      # using the dim() function.
+
+      # Use the creator functions in R
+      # You can create an array easily with the array() function, where you give the data 
+      # as the first argument and a vector with the sizes of the dimensions as the second 
+      # argument. The number of dimension sizes in that argument gives you the number of 
+      # dimensions. For example, you make an array with four columns, three rows, and 
+      # two “tables” like this:
+      my_array = R.array((1..24), dim: R.c(3,4,2))
+      # Renjin has a bug and does not print correctly multi-dimensional array, printing
+      # them as one-dimensional vector.
+      # Correct output should be something like:
+      # , , 1
+      # [,1] [,2] [,3] [,4]
+      # [1,]  1  4  7  10
+      # [2,]  2  5  8  11
+      # [3,]  3  6  9  12
+      # , , 2
+      # [,1] [,2] [,3] [,4]
+      # [1,]  13  16  19  22
+      # [2,]  14  17  20  23
+      # [3,]  15  18  21  24
+      my_array.pp
+      my_array.dim.pp
+
+      # This array has three dimensions. Notice that, although the rows are given as the 
+      # first dimension, the tables are filled column-wise. So, for arrays, R fills the 
+      # columns, then the rows, and then the rest.
+
+      # Change the dimensions of a vector in R
+      # Alternatively, you could just add the dimensions using the dim() function. This is 
+      # a little hack that goes a bit faster than using the array() function; it’s especially 
+      # useful if you have your data already in a vector. (This little trick also works for 
+      # creating matrices, by the way, because a matrix is nothing more than an array with 
+      # only two dimensions.)
+
+      # Say you already have a vector with the numbers 1 through 24, like this:
+      my_vector = R.c((1..24))
+      my_vector.pp
+      
+      # You can easily convert that vector to an array exactly like my_array simply by 
+      # assigning the attribute dimensions, like this:
+      my_vector.attr.dim = R.c(3, 4, 2)
+      my_vector.attr.dim.pp
+
+      # You can check whether two objects are identical by using the identical function. To 
+      # check, for example, whether my_vector and my_array are identical, you simply do the 
+      # following:
+      my_array.identical(my_vector).pp
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "access array elements with indexing" do
+
+      my_array = R.array((1..24), dim: R.c(3,4,2))
+
+      # getting a subarray of the original array: is a 4 * 2 array with dimension vector 
+      # c(4,2) and data vector containing the values
+      sub = my_array[2, nil, nil]
+      sub.pp
+      sub.attr.dim.pp
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "allow usage of index arrays" do
+
+      # As well as an index vector in any subscript position, a matrix may be used with a 
+      # single index matrix in order either to assign a vector of quantities to an irregular 
+      # collection of elements in the array, or to extract an irregular collection as a vector.
+
+      # A matrix example makes the process clear. In the case of a doubly indexed array, an 
+      # index matrix may be given consisting of two columns and as many rows as desired. The 
+      # entries in the index matrix are the row and column indices for the doubly indexed 
+      # array. Suppose for example we have a 4 by 5 array X and we wish to do the following:
+
+      # Extract elements X[1,3], X[2,2] and X[3,1] as a vector structure, and
+      # Replace these entries in the array X by zeroes.
+      # In this case we need a 3 by 2 subscript array, as in the following example.
+      x = R.array((1..20), dim: R.c(4,5))   # Generate a 4 by 5 array.
+      x.pp
+
+      # Now create an index array: i is a 3 by 2 index array.
+      i = R.array(R.c((1..3), (3..1)), dim: R.c(3,2))
+      i.pp
+
+      # Extract all elements in the index array
+      x[i].pp 
+
+      # Now replace those elements by zeros
+      x[i] = 0
+      x.pp
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "apply outer function to arrays" do
+
+      # outer() function applies a function to two arrays.
+      # outer(x, y, FUN="*", ...)
+      # x %o% y
+
+      # x,y: arrays
+      # FUN: function to use on the outer products, default is multiply
+
+      x = R.c(1, 2.3, 2, 3, 4, 8, 12, 43)
+      y = R.c(2, 4)
+
+      # Calculate logarithm value of array x elements using array y as bases:
+      R.outer(x, y, "log").pp
+
+      # calling outer on the vector directly
+      x.outer(y, "log").pp
+
+      # Add array x elements with array y elements:
+      x.outer(y, "+").pp
+
+      # Multiply array x elements with array y elements:
+      mult = x._ :o, y  #equal to outer(x,y,"*")
+      mult.pp
+
+      # same as above
+      x.outer(y, "*").pp
+
+      # Concatenate characters to the array elements:
+      z = R.c("a","b")
+      x.outer(z, "paste").pp
+
+    end
+
+  end
+
+end

data/test/test_attributes.rb

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Copyright © 2013 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 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require 'env'
+require 'scicom'
+
+class SciComTest < Test::Unit::TestCase
+
+  context "R environment" do
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    # Creating a variable in R and assign a value to it.  In this case assign the NULL 
+    # value.  There are two ways of assign variables in R, through method assign or with
+    # the '=' method.  To retrieve an R variable just acess it in the R namespace.
+    #--------------------------------------------------------------------------------------
+
+    should "assign attributes to objects" do
+
+      vec = R.c(1, 2, 3, 4)
+      vec.attr.name = "my.attribute"
+      vec.attr.truth = true
+      vec.attr.column_names = R.c("one", "two", "three", "four")
+      vec.attr.values = R.c((1..3))
+      vec.pp
+
+      # retrieve attr
+      assert_equal("my.attribute", vec.attr.name.gz)
+      assert_equal(true, vec.attr.truth.gt)
+      assert_equal("one", vec.attr.column_names.get(0))
+      assert_equal("three", vec.attr.column_names.get(2))
+      assert_equal(1, vec.attr.values.gz)
+
+      vec.attr.column_names[(1..2)] = R.c("1", "2")
+      assert_equal(true, (R.c("1", "2", "three", "four").eq vec.attr.column_names).gt)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "assign special attributes to objects" do
+
+      # simple matrix with dimnames
+      mat = R.cbind(a: (1..3), pi: Math::PI) 
+
+      # retrieve dimnames. dimnames is a list.
+      lst = mat.attr.dimnames
+      # dimnames is a list.  In R, dimnames is a list with two elements.  The first is NULL
+      # (always?) and the second is an array with the actual names
+      assert_equal(nil, lst[[1]])
+      assert_equal("a", lst[[2]][1].gz)
+      assert_equal("pi", lst[[2]][2].gz)
+
+      # mat does also have attribute dim
+      assert_equal(3, mat.attr.dim.get(0))
+      assert_equal(2, mat.attr.dim.get(1))
+
+      # We cannot set 'class' attribute in an R vector by calling .class as this is a 
+      # Ruby method.  We substiture the .class method by .rclass.  However, in the R
+      # namespace the attribute set is actually 'class'.
+      mat.attr.rclass = "myClass"
+      assert_equal("myClass", mat.attr.rclass.get(0))
+      # retrieving the 'class' attribute by calling eval.
+      assert_equal("myClass", R.eval("attr(#{mat.r}, \"class\")").gz)
+
+      # Attribute 'comment' should not be seen when printed, but is there normally.  In
+      # Renjin this attr does show up when printed
+      mat.attr.comment = "this is my comment on this matrix"
+
+      mat.pp
+      
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "modify attributes in chains" do
+
+      # define a list with given names as attr
+      z = R.list(a: 1, b: "c", c: (1..3))
+
+      assert_equal("a", z.attr.names.gz)
+      assert_equal("b", z.attr.names.get(1))
+      assert_equal("c", z.attr.names.get(2))
+
+      # modify one of the names' attributes
+      z.attr.names[3] = "c2"
+      assert_equal(true, (R.c("a", "b", "c2").eq z.attr.names).gt)
+
+      # modify all names attribute directly
+      z.attr.names = R.c("d", "e", "f")
+      assert_equal(true, (R.c("d", "e", "f").eq z.attr.names).gt)
+
+      # create a vector with the names attribute. Vector names is now an alias to 
+      # z.attr.names.
+      names = z.attr.names
+      assert_equal(true, (R.c("d", "e", "f").eq names).gt)
+      # change the names vector
+      names[1] = "g"
+      assert_equal(false, (R.c("d", "e", "f").eq names).gt)
+      assert_equal(true, (R.c("g", "e", "f").eq names).gt)
+
+      # differently from R, the names' attribute is also changed
+      assert_equal(false, (R.c("d", "e", "f").eq z.attr.names).gt)
+      assert_equal(true, (R.c("g", "e", "f").eq z.attr.names).gt)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "unbind a vector from the attributes in chains" do
+
+      # define a list with given names as attr
+      z = R.list(a: 1, b: "c", c: (1..3))
+
+      # change the names using normal call to R.c and channing
+      z.attr.names = R.c("d", "e", "f")
+
+      # create a vector with the names attribute. Vector names is now an alias to 
+      # z.attr.names.
+      names = z.attr.names
+      assert_equal(true, (R.c("d", "e", "f").eq names).gt)
+
+      # unbind names from z.attr.names.
+      names.unbind
+
+      # change the names vector
+      names[1] = "g"
+      assert_equal(false, (R.c("d", "e", "f").eq names).gt)
+      assert_equal(true, (R.c("g", "e", "f").eq names).gt)
+
+      # the names' attribute is NOT changed, as unbind on names was called
+      assert_equal(true, (R.c("d", "e", "f").eq z.attr.names).gt)
+      assert_equal(false, (R.c("g", "e", "f").eq z.attr.names).gt)
+
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "change attributes through normal R calls" do
+
+     # define a list with given names as attr
+      z = R.list(a: 1, b: "c", c: (1..3))
+
+      # Vector names is a copy of names attribute.
+      names = R.attr(z, "names")
+      assert_equal(true, (R.c("a", "b", "c").eq z.attr.names).gt)
+
+      # changing names...
+      names[1] = "hello there"
+      assert_equal(true, (R.c("hello there", "b", "c").eq names).gt)
+
+      # ... does not change the names attribute and there is no need to call unbind,
+      # as names was never bound to the chain
+      assert_equal(true, (R.c("a", "b", "c").eq z.attr.names).gt)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "assign attributes between objects" do
+
+      # define a list with given names as attr
+      z = R.list(a: 1, b: "c", c: (1..3))
+
+      # define a vector with the same number of elements as the list
+      vec = R.c((1..3))
+      vec.attr.names = z.attr.names
+      vec.attr.names[1] = "ggg"
+      # changing vec names does not have any impact on z.names
+      assert_equal(true, (R.c("ggg", "b", "c").eq vec.attr.names).gt)
+      assert_equal(true, (R.c("a", "b", "c").eq z.attr.names).gt)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "acess vector data by using indexing with 'names' attribute" do
+
+      # Must be careful... any assignment to a vector (object?) creates a new object
+      # value in Ruby will reference the old object and they will be different.
+      dbl_var = R.eval("var = c(1, 2, 3, 4)")
+      dbl_var.attr.names = R.c("one", "two", "three", "four")
+      dbl_var.attr.name = "my.name"
+      dbl_var.pp
+
+      # access element on a vector by name 
+      dbl_var["one"].pp
+      assert_equal(2, dbl_var["two"].gz)
+      assert_equal(4, dbl_var["four"].gz)
+
+      R.eval <<EOF
+         l = c(1, 2, 3, 4)
+         attr(l, "name") = "my.name"
+         print(attributes(l))
+
+         # l2 = l
+         # print(attributes(l2))
+EOF
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "acess data by using accessor methods from 'names' attribute" do
+
+      dbl_var = R.eval("var = c(1, 2, 3, 4)")
+      dbl_var.attr.names = R.c("one", "two", "three", "four")
+
+      assert_equal(1, dbl_var.one.gz)
+      assert_equal(2, dbl_var.two.gz)
+      assert_equal(3, dbl_var.three.gz)
+      assert_equal(4, dbl_var.four.gz)
+
+    end
+
+  end
+
+end