scicom 0.2.0-java

data/test/test_basic.rb

@@ -0,0 +1,156 @@
+# -*- 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 "get info from the workspace" do
+
+      # get default R options
+      opts = R.options
+      
+      p "Some R options:"
+      print("\n")
+      # access the options through their names
+      p "timeout is: #{opts.timeout.gz}"
+      p "na.action: #{opts.na__action.gz}"
+      p "prompt: #{opts.prompt.gz}"
+      p "help.search: #{opts.help__search__types.gz}"
+      p "show error message: #{opts.show__error__messages.gz}"
+      print("\n")
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "work with missing numbers" do
+
+      # Since every value is a vector in R, .gt returns the 0th index of the vector as
+      # a truth value
+      assert_equal(false, R.is__na(10).gt)
+      assert_equal(true, R.is__na(NA).gt)
+
+      # this will result in error.  In R is.na(NaN) is true and in Renjin it's false
+      # R.eval("print(is.na(NaN))")
+      # assert_equal(true, R.is__na(NaN).gt)
+
+      # R.is__na and R.na? are both valid and do the same thing
+      assert_equal(false, R.na?(10).gt)
+      assert_equal(false, R.na?(10.35).gt)
+      assert_equal(false, R.na?(R.eval("10L")).gt)
+      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))
+      
+      p "checking if NULL is na"
+      R.eval("is.na(NULL)").pp
+
+      # Check NA property on a vector
+      vec = R.is__na(R.c(10.35, 10.0, 56, NA))
+
+      # remember that in the Renjin::Vector class the first element is index 1
+      assert_equal(false, vec[1].gt)
+      assert_equal(true, vec[4].gt)
+
+      # gt also works with an index.  Remember .gt converts Renjin::Vector to MDArray and
+      # MDArray's first element is idexed by 0.
+      assert_equal(false, vec.gt(0))
+      assert_equal(false, vec.gt(1))
+      assert_equal(false, vec.gt(2))
+      assert_equal(true, vec.gt(3))
+
+      # Check NaN properties
+      assert_equal(true, R.is__nan(NaN).gt)
+      assert_equal(true, R.nan?(NaN).gt)
+      # Those are NaN
+      assert_equal(false, R.nan?(NA).gt)
+      
+      # The result of is.nan(NULL) is logical(0). If we try to access a 0 length vector
+      # in SciCon a RuntimeError is raised
+      assert_raise ( RuntimeError ) { R.nan?(nil).gt }
+      assert_raise ( RuntimeError ) { R.nan?(R.eval("NULL")).gt }
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "work with infinites" do
+
+      # Infinite number
+      p Inf.gz
+
+      # Negative infinite number, equivalent to "-Inf" in R
+      p MInf.gz
+
+      assert_equal(Inf, Inf)
+      assert_equal(false, R.finite?(Inf).gt)
+      assert_equal(false, R.finite?(MInf).gt)
+
+      # Check if the number if finite
+      assert_equal(true, R.finite?(10).gt)
+      assert_equal(true, R.finite?(10.35).gt)
+
+      # chekc numbers to see if they are finite
+      # assert_equal(false, R.finite?(R.NaN_double))
+
+      assert_equal(false, R.finite?(NA).gt)
+      # assert_equal(false, R.finite?(R.NaN_double))
+
+      # Check a vector for the finite? property
+      R.finite?(R.c(2, 3, 4))
+      R.finite?(R.eval("10.456"))
+      
+      # Int_NA is finite; however R.NA_double is not finite.  Is this correct? Should 
+      # check with the Renjin team.
+      assert_equal(false, R.finite?(NA).gt)
+
+    end
+
+  end
+
+end

data/test/test_column-major.rb

@@ -0,0 +1,114 @@
+# -*- 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 
+
+      # creating two distinct instances of SciCom
+      @r1 = R.new
+      @r2 = R.new
+
+    end
+
+
+    #--------------------------------------------------------------------------------------
+    # We should be able to create MDArray with different layouts such as row-major, 
+    # column-major, or R layout.
+    #--------------------------------------------------------------------------------------
+
+    should "work with colum-major indexes" do
+
+      col2 = MDArray.double([2, 3, 4], 
+                            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+                            17, 18, 19, 20, 21, 22, 23], 
+                            :column)
+      col2.print
+
+      assert_equal(0, col2[0, 0, 0])
+      assert_equal(3, col2[0, 0, 1])
+      assert_equal(6, col2[0, 0, 2])
+      assert_equal(9, col2[0, 0, 3])
+
+      # slice the col array. take a slice of c on the first dimension (0) and taking only 
+      # the first (0) index,we should get the following array:
+      # [[0.00 3.00 6.00 9.00]
+      #  [1.00 4.00 7.00 10.00]
+      #  [2.00 5.00 8.00 11.00]]
+      slice = col2.slice(0, 0)
+      assert_equal(0, slice[0, 0])
+      assert_equal(3, slice[0, 1])
+      assert_equal(6, slice[0, 2])
+      assert_equal(9, slice[0, 3])
+      
+    end
+
+=begin
+    
+    #--------------------------------------------------------------------------------------
+    # We should be able to create MDArray with different layouts such as row-major, 
+    # column-major.
+    #--------------------------------------------------------------------------------------
+
+    should "work with R layout" do
+
+      ret = @r1.eval("vec=c(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23)")
+      @r1.eval("dim(vec) = c(2, 3, 4)")
+
+      p "returned array is"
+      ret.print
+
+      @r1.eval("print(vec[1, 1, 1])")
+      @r1.eval("print(vec[1, 1, 2])")
+      @r1.eval("print(vec[1, 1, 3])")
+      @r1.eval("print(vec[1, 1, 4])")
+
+    end
+
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "raise when layout is unknown" do
+
+      assert_raise ( RuntimeError ) { 
+        MDArray.double([2, 2, 3], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], :unk)
+      }
+      
+    end
+=end
+  end
+
+end

data/test/test_complete.rb

@@ -0,0 +1,49 @@
+# -*- 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'
+
+require_relative 'test_R_interface'
+require_relative 'test_creation'
+require_relative 'test_basic'
+require_relative 'test_vector'
+require_relative 'test_operators'
+require_relative 'test_list'
+require_relative 'test_attributes'
+require_relative 'test_factor'
+require_relative 'test_array'
+require_relative 'test_matrix'
+require_relative 'test_dataframe'
+require_relative 'test_linear_model'
+
+=begin
+require_relative 'test_subsetting'
+require_relative 'test_double_receive'
+require_relative 'test_double_assign'
+require_relative 'test_functions'
+require_relative 'test_user_function'
+require_relative 'test_column-major'
+=end

data/test/test_creation.rb

@@ -0,0 +1,299 @@
+# -*- 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 integer variable" do
+
+      # In R, every number is a vector.  R Vector's are converted to Ruby Renjin::Vector  
+      # (a new class defined by SciCom).  
+      # An int can be created by calling 'eval'...
+      i1 = R.eval("10L")
+
+      # ... or it can be created by calling the 'i' method.
+      i2 = R.i(10)
+
+      # Method .r can be used in a Ruby vector to make it available in the R namespace
+      R.eval("print(#{i2.r})")
+
+      # both i1 and i2 are vectors.  To print a vector we use method .pp
+      i1.pp
+      i2.pp
+
+      # Integer nuberic Vectors are created with method .i
+      # the returned value is a Renjin::Vector
+      my_int = R.i(10)
+      assert_equal(10, my_int.gz)
+      # method typeof returns the type of this vector
+      assert_equal("integer", my_int.typeof.gz)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "create double variable" do
+
+      R.eval("i1 = 10.2387")
+      # the returned value is a Renjin::Vector
+      i1 = R.i1
+      assert_equal(10.2387, i1.gz)
+
+      # assign to an R variable the Vector returned previously.  The original variable
+      # is still valid
+      R.assign("i2", i1)
+      assert_equal(10.2387, R.i2.gz)
+      assert_equal(10.2387, R.i1.gz)
+
+      # type of i2 is a double
+      assert_equal("double", R.eval("typeof(i2)").gz)
+      # same call can be done easier.  Remember, i2 is defined only in the R namespace.
+      assert_equal("double", R.typeof(R.i2).gz)
+
+      # create a double without calling eval.  Method .d creates a double vector with
+      # one element. Variable i2 is now defined in the Ruby namespace
+      i2 = R.d(345.7789)
+      assert_equal("double", i2.typeof.gz)
+      assert_equal(345.7789, i2.gz)
+
+      # Creating a double vector is done with R.d.  From now on we will use preferably
+      # Ruby integration and not use 'eval'.  'eval' will be used sometimes just to show
+      # that it works and that a user that prefers to use SciCom with a standard R 
+      # loook and feel can still do it.
+      dbl = R.d(10.25)
+      # Prints the vector (R notation)
+            
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "acess variable content with .gz and .gt" do
+
+      # In order to access the value of a variable for it to be used in Ruby, method .gz is 
+      # used.  Later will see method get and why the name for the method as .gz.
+      dbl = R.d(10.25)
+      assert_equal(10.25, dbl.gz)
+
+      # When looking at a logical vector, method .gt gets the truth value of the vector
+      var = R.c(TRUE)
+      assert_equal(true, var.gt)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "create complex variable" do
+
+      # complex vector: created by calling R.complex. Real and imaginary parts are obtained
+      # by calling R.Re and R.Im functions on the variable.
+
+      comp_var = R.complex(real: 2, imaginary: 1)
+      assert_equal(2, R.Re(comp_var).gz)
+      assert_equal(1, R.Im(comp_var).gz)
+
+      p "complex"
+
+      comp = R.as__complex(-1)
+      assert_equal(-1, R.Re(comp).gz)
+      assert_equal(0, R.Im(comp).gz)
+      assert_equal(true, R.is__complex(comp).gt)
+
+      # The (x, y) representation of numbers is easier to understand at first, but a 
+      # polar coordinates representation is often more practical. You can get the 
+      # relevant components of this representation by finding the modulus and complex 
+      # argument of a complex number. In R, you would use Mod and Arg:
+
+      z = R.complex(real: 0, imaginary: 1)
+ 
+      R.Mod(z).pp
+      # [1] 1
+      
+      R.Arg(z).pp
+      # [1] 1.570796
+      
+      # Finally, you’ll want to be able to take the complex conjugate of a complex 
+      # number; to do that in R, you can use Conj:
+      R.Conj(z).pp
+      # [1] 0-1i
+ 
+      # Obtain components of a complex number in polar coordinates
+      comp = R.complex(imaginary: 1, real: 0)
+      mod = R.Mod(comp)
+      arg = R.Arg(comp)
+      assert_equal(true, ((R.pi/R.d(2)).gz == arg.gz))
+      assert_equal(false, ((R.pi/R.d(2)).gz == mod.gz))
+
+      # To get the complex square root, you need to cast your negative number as a 
+      # complex number using as__complex before applying sqrt:
+      R.as__complex(-1).pp
+      # Renjin not implemented yet
+      # R.sqrt(R.as__complex(-1)).pp
+      R.sqrt(-1).pp
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "create string variable" do
+
+      R.str1 = "hello there;"
+
+      # method get, gets the current element
+      assert_equal("hello there;", R.str1.gz)
+
+      R.str2 = "This is another string"
+      assert_equal("This is another string", R.str2.gz)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "create vectors with more than one element (R.c)" do
+
+      # To create vectors in R, one uses the 'c' function.  Use R.c to created vectors
+      # in SciCom
+
+      vec = R.c(1, 2, 3, 4, 5)
+      assert_equal(true, (R.d(1).eq vec[1]).gt)
+      assert_equal(true, (R.d(2).eq vec[2]).gt)
+
+      # In R, indexing a vector with zero returns Vector numeric(0)
+      oops = vec[0]
+      oops.pp
+
+      # Calling get on numeric(0) raises an exception
+      assert_raise ( RuntimeError ) { oops.get }
+
+      # 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)
+
+      # Converting to Ruby will return NaN (Not a Number)
+      assert_equal(NaN, na.gz)
+
+      # Method get can be used with an index, to get a given element of a vector
+      assert_equal(1, vec.get(0))
+      assert_equal(4, vec.get(3))
+
+      # method R.c also works with strings
+      str = R.c("this is the first string", "this is the second string")
+      str.pp
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "accept (from..to) operators" do
+
+      # Vectors can be created using (from..to) or (from...to) operators in place where
+      # R uses ':' notation.  (1..4) is a range that goes from 1 to 4 and (1...4) is a 
+      # range that goes from 1 to 3.
+      vec1 = R.c((1..4))
+      vec1.pp
+
+      # Method length return the number of elements in a vector
+      assert_equal(4, vec1.length)
+      # The same can be obtained by calling length in R, but remember that R always returns
+      # a vector.
+      R.length(vec1).pp
+      
+      # to use assert_equal, we need to get the vector's content
+      assert_equal(4, R.length(vec1).gz)
+
+      # We can also acess a Ruby vector in R by calling the .r method in this vector
+      R.eval("print(#{vec1.r})")
+
+      vec2 = R.c((1...4))
+      vec2.pp
+
+      # vec2 has only three elements
+      assert_equal(3, vec2.length)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "create vectors with method seq" do
+      
+      # create a sequence (from, to)
+      seq1 = R.seq(2, 10)
+      seq1.pp
+
+      # R options can also be used, although the notation is a little different.  In
+      # R we would call seq(2, 10, by = 3).  In SciCom the same call is R.seq(2, 10, by: 3)
+      seq2 = R.seq(2, 10, by: 3)
+      seq2.print
+
+      # giving the number of required elements in the sequence
+      seq3 = R.seq(2, 100, length: 12)
+      seq3.pp
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "create vectors with method rep" do
+
+      vec = R.rep(R.c(1, 2, 3), 3)
+      vec.pp
+
+    end
+
+  end
+  
+end