scicom 0.3.0-java → 0.4.0-java

data/lib/scicom.rb

@@ -23,7 +23,5 @@
 
 require 'mdarray'
 
-require_relative 'env'
+require_relative '../config'
 require_relative 'JRubyR/renjin'
-
-

data/test/test_R_interface.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase

data/test/test_array.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase

data/test/test_assign_mdarray.rb

@@ -24,7 +24,7 @@ require 'test/unit'
 require 'shoulda'
 require 'benchmark'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase

data/test/test_assign_mdarray_2d.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase

data/test/test_assign_mdarray_3d.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase

data/test/test_attributes.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase

data/test/test_basic.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 
@@ -82,9 +82,10 @@ class SciComTest < Test::Unit::TestCase
       assert_equal(false, R.na?(R.eval("10.456")).gt)
 
       # Use nil in Ruby when needing a NULL in R
-      p "R prints Warning message when is.na is applied to a value and not a vector: "
-      #assert_equal(0, R.length(R.na?(nil).gt))
-      
+      # Cheching if nil is na returns an empty vector, size 0
+      assert_equal(0, R.na?(nil).length.gz)
+
+      # Does the same thing as above inside an R script
       p "checking if NULL is na"
       R.eval("is.na(NULL)").pp
 
@@ -127,7 +128,8 @@ class SciComTest < Test::Unit::TestCase
       # Negative infinite number, equivalent to "-Inf" in R
       p MInf.gz
 
-      assert_equal(Inf, Inf)
+      assert_equal(true, R.is__infinite(Inf).gt)
+      assert_equal(true, R.is__infinite(MInf).gt)
       assert_equal(false, R.finite?(Inf).gt)
       assert_equal(false, R.finite?(MInf).gt)
 

data/test/test_callback.rb

@@ -0,0 +1,176 @@
+# -*- 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 '../config' if @platform == nil
+require 'scicom'
+
+class SciComTest < Test::Unit::TestCase
+
+  context "R environment" do
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
+      
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "callback rpacked classes Array and Hash" do
+
+      # create an array of data in Ruby
+      array = [1, 2, 3]
+
+      # Pack the array and assign it to an R variable.  Remember that ruby__array, becomes
+      # ruby.array inside the R script
+      R.ruby__array = R.rpack(array)
+
+      # note that this calls Ruby method 'length' on the array and not R length function.
+      R.eval("val <- ruby.array$run('length')")
+      assert_equal(3, R.val.gz)
+
+      # Let's use a more interesting array method '<<'.  This method adds elements to the
+      # end of the array.  
+
+      R.eval(<<-EOT)
+        print(typeof(ruby.array))
+        ruby.array$run('<<', 4)
+        ruby.array$run('<<', 5)
+      EOT
+      assert_equal(4, array[3])
+      assert_equal(5, array[4])
+
+      # Although the concept of chainning is foreign to R, it does apply to packed
+      # classes
+      R.eval(<<-EOT)
+        ruby.array$run('<<', 6)$run('<<', 7)$run('<<', 8)$run('<<', 9)
+      EOT
+      assert_equal(9, array[8])
+      
+      # Let's try another method... remove a given element from the array
+      R.eval(<<-EOT)
+        ruby.array$run('delete', 4)
+      EOT
+      assert_equal(5, array[3])
+
+      # We can also acess any array element inside the R script, but note that we have
+      # to use Ruby indexing, i.e., the first element of the array is index 0
+      R.eval(<<-EOT)
+        print(ruby.array$run('[]', 0))
+        print(ruby.array$run('[]', 2))
+        print(ruby.array$run('[]', 4))
+        print(ruby.array$run('[]', 6))
+      EOT
+
+      # Try the same with a hash
+      hh = {"a" => 1, "b" =>2}
+
+      # Pack the hash and store it in R variable r.hash
+      R.r__hash = R.rpack(hh, scope: :external)
+
+      # Retrieve the value of a key
+      R.eval(<<-EOT)
+        h1 <- r.hash$run('[]', "a")
+        h2 <- r.hash$run('[]', "b")
+      EOT
+      assert_equal(1, R.h1.gz)
+      assert_equal(2, R.h2.gz)
+
+      # Add values to the hash
+      R.eval(<<-EOT)
+        h1 <- r.hash$run('[]=', "c", 3)
+        h2 <- r.hash$run('[]=', "d", 4)
+      EOT
+      assert_equal(3, hh["c"])
+      assert_equal(4, hh["d"])
+      
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "allow use of Ruby classes and objects inside an R script" do
+
+      R.eval(<<-EOT)
+        # This is an actuall R script, which allows the creation and use of Ruby classes
+        # and methods.
+        # Create a string, from class String in Ruby.  Use function build to intanciate a 
+        # new object
+        string <- Ruby.Object$build("String", "this is a new string")
+
+        # Use function get_class to get a Ruby class
+        Marshal <- Ruby.Object$get_class("Marshal")
+
+        # Method 'dump' is a Marshal class method as is 'load' 
+        str <- Marshal$run("dump", string)
+        restored <- Marshal$run("load", str)
+      EOT
+      
+      assert_equal("this is a new string", R.string.gz)
+      assert_equal(Marshal.dump("this is a new string"), R.str.gz)
+      assert_equal("this is a new string", R.restored.gz)
+
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "callback all internal elements" do
+
+      # Create two arrays and store them in a third array
+      props1 = [1, 2, 3]
+      props2 = [10, 20]
+      props = [props1, props2]
+
+      # rpack the internal's of the container array props, i.e, pack only arrays
+      # props1 and props2.  Array props is not being packed as Ruby arrays are morphed
+      # into R lists.  And a list good for what we want.  In order to work on R side
+      # we store the packed array into variable 'jake'
+      R.jake = R.rpack(props, scope: :internal)
+
+      R.eval(<<-EOT)
+        # We want to find the vector with the least elements we have stored.  We can use
+        # sapply to get the length of all vectors.  Although variable 'jake' is a regular
+        # R list, it's internal elements are rpacked Ruby objects
+        smallest <- which.min(sapply(jake, function(x) x$run("length")))
+
+        # Remember, the list has only rpacked Ruby objects.  To print it, we need to convert
+        # it to a string.
+        print(jake[[smallest]]$run('to_s'))
+      EOT
+      
+      # R.eval("val <- sapply(jake, function(x) x$run('length'))")
+
+    end
+    
+  end
+  
+end

data/test/test_complete.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 require_relative 'test_R_interface'

data/test/test_creation.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase
@@ -215,10 +215,10 @@ class SciComTest < Test::Unit::TestCase
       # Accessing a value outside of the defined vector bound returns a vector with 
       # one element, the NA (Not Available)
       na = vec[10]
-      assert_equal(NA, na)
+      assert_equal(true, R.is__na(na).gt)
 
       # Converting to Ruby will return NaN (Not a Number)
-      assert_equal(NaN, na.gz)
+      assert_equal(true, (na.gz).nan?)
 
       # Method get can be used with an index, to get a given element of a vector
       assert_equal(1, vec.get(0))
@@ -243,7 +243,7 @@ class SciComTest < Test::Unit::TestCase
       vec1.pp
 
       # Method length return the number of elements in a vector
-      assert_equal(4, vec1.length)
+      assert_equal(4, vec1.length.gz)
       # The same can be obtained by calling length in R, but remember that R always returns
       # a vector.
       R.length(vec1).pp
@@ -258,7 +258,7 @@ class SciComTest < Test::Unit::TestCase
       vec2.pp
 
       # vec2 has only three elements
-      assert_equal(3, vec2.length)
+      assert_equal(3, vec2.length.gz)
 
     end
 
@@ -294,6 +294,30 @@ class SciComTest < Test::Unit::TestCase
 
     end
 
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "create lists" do
+
+      p "creating list"
+      R.eval("lst = c('a', 'b', 'c')")
+      R.eval("print(lst)")
+      # the returned value is a list
+      rb_lst = R.lst
+      p "this is the list"
+      rb_lst.pp
+
+      # assign to an R variable the rb_lst returned previously.  The original variable
+      # is still valid
+      R.assign("lst2", rb_lst)
+      R.eval("print(lst2)")
+      R.lst2 = R.c("new list")
+      R.lst.pp
+      R.lst2.pp
+
+    end
+    
   end
   
 end

data/test/test_dataframe.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase

data/test/test_factor.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase

data/test/test_functions.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 
@@ -45,21 +45,24 @@ class SciComTest < Test::Unit::TestCase
 
     should "keep reference and call R functions" do
 
-      var = R.c((0..10), 50)
-      R.mean(var).pp
-      R.mean(var, trim: 0.10).pp
-
+      # f contais a reference to the R 'mean' function in the Ruby namespace, not in Renjin
+      # namespace.  This is actually of type Renjin::Closure
       f = R.eval("mean")
-      f.call(R.c(2, 3)).pp
-      f.call(var, trim: 0.10).pp
+      assert_equal(2.5, f.call(R.c(2, 3)).gz)
 
-      ff = R.d("mean")
-      ff.call(var, trim: 0.10).pp
+      # using function 'mean' as parameter
+      mean = R.lapply(R.c(2, 3), "mean")
+      mean.pp
 
+      # we can also use function 'f' which was assigned to 'mean'
+      mean = R.lapply(R.c(2, 3), f)
+      mean.pp
+      
+=begin      
       sum = R.eval("sum")
       dgamma = R.eval("dgamma")
       p dgamma
-
+=end
     end
 
   end

data/test/test_linear_model.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase

data/test/test_list.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase
@@ -48,6 +48,9 @@ class SciComTest < Test::Unit::TestCase
       @trth_vec2 = R.c(FALSE, FALSE)
       @gl = R.gl(2, 3)
 
+      # names is a Ruby array
+      @names = ["Lisa", "Teasha", "Aaron", "Thomas"]
+
     end
 
     #--------------------------------------------------------------------------------------
@@ -93,7 +96,12 @@ class SciComTest < Test::Unit::TestCase
       assert_equal("character", @x[["second"]].typeof.gz)
       assert_equal("yes", @x[["second"]][1].gz)
       assert_equal(2, @x[["fourth"]][4].gz)
-      
+
+      assert_equal("first", @x.names[1].gz)
+      assert_equal("second", @x.names[2].gz)
+      assert_equal("third", @x.names[3].gz)
+      assert_equal("fourth", @x.names[4].gz)
+
     end
 
     #--------------------------------------------------------------------------------------
@@ -173,25 +181,56 @@ class SciComTest < Test::Unit::TestCase
 
     end
 
+    #--------------------------------------------------------------------------------------
+    # Assign a Ruby array to R.  The array is converted into a list.
+    #--------------------------------------------------------------------------------------
+
+    should "be able to assign a Ruby array to R" do
+
+      # Ruby Arrays can be used as arguments to R functions.  A Ruby Array will be
+      # converted to an R list.
+      people = R.identity(@names)
+
+      # Indexing of lists can be done by [x] or [[x]].  The first indexing still returns a
+      # list while the latter returns an element of the list.  In the latter case we can
+      # use gz to retrieve the value of the element, on the first case, gz does not work
+      # as we cannot get convert the first element of a list to a Ruby value.
+      assert_equal("Lisa", people[[1]].gz)
+      assert_equal("Teasha", people[[2]].gz)
+      assert_equal("Aaron", people[[3]].gz)
+      assert_equal("Thomas", people[[4]].gz)
+
+      assert_equal(true, (R.list("Lisa")._ :in, people[1]).gt)
+      assert_equal(false, (R.list("Lisa")._ :in, people[2]).gt)
+
+    end
+
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
-    should "be able to assign a Ruby array to R (not really recommended)" do
+    should "unlist a list" do
 
-      # names is a Ruby array
-      names = ["Lisa", "Teasha", "Aaron", "Thomas"]
+      people = R.convert(@names)
+      vec = people.unlist
+      assert_equal("Lisa", vec[1].gz)
+      assert_equal("Teasha", vec[2].gz)
+      assert_equal("Aaron", vec[3].gz)
+      assert_equal("Thomas", vec[4].gz)
 
-      # Ruby Arrays can be used as arguments to R functions.  An Ruby Array will be
-      # converted to an R list.
-      people = R.identity(names)
-      people.pp
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "assign values to Ruby variables and R variables" do
 
       # If a Ruby Array is assigned to an R variable, this R variable is a list.  Note
       # that variable 'people' above and variable 'R.people' are two different variables.
       # While the first is defined in the Ruby environment, the second is defined in 
       # R environment.
-      R.people = names
+      R.people = @names
       R.people.pp
 
       R.lst = [1, 2, 3, 4, 5, 6]