scicom 0.2.0-java

data/test/test_mdarray.rb

@@ -0,0 +1,258 @@
+# -*- 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 "convert a vector to an MDArray" do
+
+      # Method 'get' converts a Vector to an MDArray
+      vec = i3.get
+      assert_equal(true, vec.is_a?(MDArray))
+      assert_equal("int", vec.type)
+
+      # For consistancy with R notation one can also call as__mdarray to convert a 
+      # vector to an MDArray
+      vec2 = i3.as__mdarray
+      assert_equal(true, vec2.is_a?(MDArray))
+      assert_equal("int", vec2.type)
+
+      # Now 'vec' is an MDArray and its elements can be accessed through indexing, but
+      # this time the first index is 0, and the element is an actual number
+      assert_equal(10, vec[0])
+
+      # Convert vector to an MDArray
+      array = vec2.get
+      
+      # Use array as any other MDArray...
+      array.each do |elmt|
+        p elmt
+      end
+
+      # ... although there is no need to convert a vector to an MDArray to call each:
+      # the each method is also defined for vectors
+      vec1.each do |elmt|
+        p elmt
+      end
+      
+    end
+
+=begin
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "integrate MDArray with R vector" do
+      
+      # typed_arange does the same as arange but for arrays of other type
+      arr = MDArray.typed_arange(:double, 60)
+      # MDArray is stored in row-major order
+      arr.reshape!([5, 3, 4])
+      # arr.print
+
+      R.eval <<EOF
+      print(#{arr.r});
+      vec = #{arr.r};
+print(vec);
+print(vec[1, 1, 1]);
+
+EOF
+
+end
+=end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "receive 1 Dimensional MDArrays in R" do
+      
+      vec = MDArray.double([6], [1, 3, 5, 7, 11, 13])
+      # vec is just a normal MDArray that can be changed at anytime
+      vec[0] = 2
+
+      R.prime = vec
+
+      # now vec is immutable, since it is now in Renjin and Renjin requires an immutable
+      # vector
+      assert_raise ( RuntimeError ) { vec[0] = 1 }
+
+      vec2 = R.eval("print(prime)")
+      vec2.print
+
+      assert_raise ( RuntimeError ) { vec2[1] = 7 }
+      
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "cast MDArray numeric value to different types" do
+
+      i1 = R.d(10.2387)
+
+      # double cannot be converted to boolean
+      assert_raise ( RuntimeError ) { i1.get_as(:boolean) }
+
+      # method .get_as returns the current element of MDArray, which, in this case, is the
+      # first element
+      assert_equal(10, i1.get_as(:byte))
+      assert_equal(10, i1.get_as(:char))
+      assert_equal(10, i1.get_as(:short))
+      assert_equal(10, i1.get_as(:int))
+      assert_equal(10, i1.get_as(:long))
+      assert_equal(10.238699913024902, i1.get_as(:float))
+      assert_equal(10.2387, i1.get_as(:double))
+      assert_equal("10.2387", i1.get_as(:string))
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+    
+    should "assign MDArray to R transparently" do
+
+      # MDArray instances created in Ruby namespace can also be access in the R
+      # namespace with the r method:
+      array = MDArray.typed_arange(:double, 18)
+      R.eval("print(#{array.r})")
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+    
+    should "create MDArrays from R methods" do
+
+      # R.c creates a MDArray.  In general it will be a double MDArray
+      res = R.c(2, 3, 4, 5)
+      assert_equal("double", res.type)
+      assert_equal(4, res.size)
+
+      # to create an int MDArray with R.c, all elements need to be integer.  To create an
+      # int we need R.i method
+      res = R.c(R.i(2), R.i(3), R.i(4))
+      assert_equal("int", res.type)
+      assert_equal(3, res.size)
+
+      # using == method from MDArray.  It returns an boolean MDArray
+      res = (R.c(2, 3, 4) == R.c(2, 3, 4))
+      assert_equal("boolean", res.type)
+
+      # array multiplication
+      (R.c(2, 3, 4) * R.c(5, 6, 7)).pp
+
+      # A sequence also becomes an MDArray
+      res = R.seq(10, 40)
+      res.print
+
+      res = R.rep(R.c(1, 2, 3), 3)
+      res.print
+
+    end
+
+    #======================================================================================
+    #
+    #======================================================================================
+
+    should "be able to create a double vector in R" do
+
+      vec = R.c(1, 2, 3, 4)
+
+      
+      assert_equal("1.0 2.0 3.0 4.0 ", vec.to_string)
+
+      # All methods on MDArray can be called normally
+      vec.reset_statistics
+      assert_equal(2.5, vec.mean)
+      assert_equal(1.118033988749895, vec.standard_deviation)
+      assert_equal("11.0 12.0 13.0 14.0 ", (vec + 10).to_string)
+
+    end
+
+    #======================================================================================
+    # Need to check how MDArray works exactly with NaN
+    #======================================================================================
+
+    should "work with NA and NaN in double vectors" do
+
+      vec2 = R.c(1, NA, 3, 4)
+      vec2.print
+
+      vec3 = R.c(1, NaN, 3, 4)
+      vec3.print
+
+    end
+
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "use MDArray in R" do
+      
+      # create a double MDArray
+      vec  = MDArray.typed_arange(:double, 12)
+      vec.print
+
+      # assign the MDArray to an R vector "my.vec"
+      R.my__vec = vec
+
+      # print R's "my.vec"
+      R.eval("print(my.vec)")
+
+      # use the .r method in MDArray's to get the MDArray value in R
+      R.eval("print(#{vec.r})")
+
+      # Passing an MDArray without assigning it in a R vector is also possible
+      R.eval("print(#{MDArray.typed_arange(:double, 5).r})")
+
+    end
+
+  end
+
+end

data/test/test_operators.rb

@@ -0,0 +1,227 @@
+# -*- 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 Vectors" do
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "do basic vector arithmetic" do
+
+      vec1 = R.c(1, 2.5, 4.5)
+      vec2 = R.c(3, 4, 5)
+
+      # unary minus
+      res = -vec1
+      assert_equal(true, (R.all(R.c(-1, -2.5, -4.5) == res)).gt)
+      assert_equal(false, (R.all(R.c(1, -2.5, -4.5) == res)).gt)
+
+      # unary plus
+      res = +vec1
+      assert_equal(false, (R.all(R.c(-1, -2.5, -4.5) == res)).gt)
+      assert_equal(true, (R.all(R.c(1, 2.5, 4.5) == res)).gt)
+
+      # addition
+      res = vec1 + vec2
+      assert_equal(true, (R.all(R.c(4, 6.5, 9.5) == res)).gt)
+      assert_equal(false, (R.all(R.c(4, 6.5, 9) == res)).gt)
+
+      # subtraction
+      res = vec1 - vec2
+      assert_equal(true, (R.all(R.c(-2, -1.5, -0.5) == res)).gt)
+
+      # multiplication
+      res = vec1 * vec2
+      assert_equal(true, (R.all(R.c(3, 10, 22.5) == res)).gt)
+
+      # division
+      res = vec1 / vec2
+      assert_equal(true, (R.all(R.c(0.333333333333333333333333, 0.625, 0.9) == res)).gt)
+
+      # modulus (x mod y)
+      res = vec1 % vec2
+      assert_equal(true, (R.all(R.c(1, 2.5, 4.5) == res)).gt)
+
+      # modulus (x mod y)
+      res = vec2 % vec1
+      assert_equal(true, (R.all(R.c(0, 1.5, 0.5) == res)).gt)
+
+      # integer division
+      res = vec1.int_div(vec2)
+      assert_equal(true, (R.all(R.c(0, 0, 0) == res)).gt)
+
+      # integer division
+      res = vec2.int_div(vec1)
+      assert_equal(true, (R.all(R.c(3, 1, 1) == res)).gt)
+
+      # exponetiation
+      res = vec1 ** vec2
+      assert_equal(true, (R.all(R.c(1, 39.0625, 1845.28125) == res)).gt)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "do vector comparison" do
+
+      vec1 = R.c(1, 2.5, 4.5)
+      vec2 = R.c(3, 4, 5)
+      vec3 = R.c(1, 3, 4.5)
+
+      # R.all checks to see if every element of the vector is TRUE. R.any checks to see if at
+      # least one element of the vector is TRUE.
+
+      res = vec1 < vec2
+      assert_equal(true, R.all(res).gt)
+
+      res = vec1 < vec3
+      assert_equal(false, R.all(res).gt)
+
+      res = vec1 <= vec3
+      assert_equal(true, R.all(res).gt)
+
+      res = vec1 > vec2
+      assert_equal(false, R.all(res).gt)
+
+      res = vec1 > vec3
+      assert_equal(false, R.all(res).gt)
+
+      res = vec2 > vec3
+      assert_equal(true, R.all(res).gt)
+
+      res = vec3 >= vec1
+      assert_equal(true, R.all(res).gt)
+
+      res = vec3 > vec1
+      assert_equal(false, R.all(res).gt)
+      assert_equal(true, R.any(res).gt)
+
+      res = vec2 != vec1
+      assert_equal(true, R.all(res).gt)
+
+      # comparison is done element by element.  R.all is true only if all elements on the 
+      # vector are true.  Is this case, there are elements that are equal
+      res = vec3 != vec1
+      assert_equal(false, R.all(res).gt)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "do logical vector operations" do
+
+      vec1 = R.c(TRUE, TRUE, FALSE, FALSE)
+      vec2 = R.c(TRUE, FALSE, TRUE, FALSE)
+
+      # not
+      res = !vec1
+      assert_equal(true, (R.all(R.c(FALSE, FALSE, TRUE, TRUE) == res)).gt)
+
+      # and
+      res = vec1 & vec2
+      assert_equal(true, (R.all(R.c(TRUE, FALSE, FALSE, FALSE) == res)).gt)
+      assert_equal(false, (R.all(R.c(FALSE, FALSE, FALSE, FALSE) == res)).gt)
+
+      # or
+      res = vec1 | vec2
+      assert_equal(false, (R.all(R.c(TRUE, FALSE, FALSE, FALSE) == res)).gt)
+      assert_equal(true, (R.all(R.c(TRUE, TRUE, TRUE, FALSE) == res)).gt)
+
+      # only compares the first element of the vectors.  Equivalent to R's &&
+      res = vec1.l_and(vec2)
+      assert_equal(true, res.gt)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "do arithmetic with scalars" do
+
+      vec1 = R.c(1, 2.5, 4.5)
+      vec2 = R.c(3, 4, 5)
+
+      res = vec1 + 2
+      assert_equal(true, (R.all(R.c(3, 4.5, 6.5) == res)).gt)
+
+      res = vec1 - 2
+      res = vec1 * 2
+      res = vec1 / 2 
+      res = vec1 % 2 
+      res = vec1 ** 2 
+      res = vec1 | 2
+      res = vec1 & 2
+      res = vec1 > 2
+      res = vec1 >= 2
+      res = vec1 < 2.5
+      res = vec1 <= 2.5
+      
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "coerce scalar to vector when needed" do
+
+      vec1 = R.c(1, 2.5, 4.5)
+      vec2 = R.c(3, 4, 5)
+
+      res = 2 * vec2
+      res.pp
+
+      res = 2 - vec2
+      res.pp
+
+      res = 2 > vec2
+      res.pp
+
+      res = 2 <= vec1
+      res.pp
+
+    end
+
+  end
+
+end