scicom 0.2.2-java → 0.2.3-java

data/test/test_assign_mdarray_2d.rb

@@ -0,0 +1,162 @@
+# -*- 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 "have the same backing store" do
+
+      p "arr1 and r_matrix have both the same backing store when data is converted from \
+MDArray to R"
+      arr1 = MDArray.typed_arange("double", 12)
+      arr1.reshape!([4, 3])
+      arr1.print
+
+      p "r_matrix has the same data as arr1"
+      r_matrix = R.md(arr1)
+      r_matrix.pp
+
+      # change an element of the MDArray
+      arr1[0, 0] = 10.34567
+      p "changing element is arr1 will cause the same change in r_matrix"
+      arr1.print
+
+      p "element [0, 0] of r_matrix has also changed"
+      r_matrix.pp
+
+      # WITH GREAT POWER COMES GREAT RESPONSABILITIES!
+      # r_matrix also changes... arr1 and r_matrix have the same backing store. Changing
+      # the content of an MDArray that points to the same backing store as an R vector
+      # should be done with care.  Renjin assumes that the vector will never change and
+      # delays calculation of the vector to the latest possible time.  In this case, since
+      # the value of the vector is changing, one can get unexpected behaviour.  Use with
+      # care.  We could prevent MDArray from being editable, however, we believe that
+      # allowing access to the backing store will have important implications for 
+      # performance.  If we have indication that this is not a good thing, then we will
+      # remove MDArrays ability to change the backing store of a Vector.
+      compare = MDArray.byte(arr1.shape)
+      arr1.get_index.each do |ct|
+        compare[*ct] = (arr1[*ct] == (r_matrix.ri(*ct).gz))? 1 : 0
+      end
+      comp = R.md(compare)
+      assert_equal(true, comp.all.gt)
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    # Assign an MDArray to an R vector (array)
+    #--------------------------------------------------------------------------------------
+
+    should "MDArray is organized row-major while R vectors are column-major" do
+
+      # this is a row-major matrix
+      p "arr1 is in row-major order"
+      arr1 = MDArray.typed_arange(:double, 12)
+      arr1.reshape!([4, 3])
+      arr1.print
+
+      # a vector in R is column-major
+      p "however vec is in column-major order as vec was created in R"
+      vec = R.seq(0, 11)
+      vec.attr.dim = R.c(4, 3)
+      vec.pp
+
+      # arr1 and vec are not identical, since one is organized in row-major order while
+      # the other is organized in column-major order
+      compare = MDArray.byte(arr1.shape)
+      arr1.get_index.each do |ct|
+        compare[*ct] = (arr1[*ct] == (vec.ri(*ct).gz))? 1 : 0
+      end
+      comp = R.md(compare)
+      assert_equal(false, comp.all.gt)
+
+      # Note that when creating a matrix in MDArray and converting to an R vector, the 
+      # same order is preserved, i.e., the R vector will see the data as in row-major
+      # order.  On the other hand, when a vector is created in R, it will have column-
+      # major order.  Maintaining the order from MDArray to R allows for easy and 
+      # compatible use of array in both views.
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "change backing store of R vector when changing the vector" do
+
+      # create an MDArray
+      arr1 = MDArray.typed_arange("double", 12)
+      arr1.reshape!([4, 3])
+      p "Making any changes in an Renjin object changes the object itself"
+      arr1.print
+      r_matrix = R.md(arr1)
+      p "r_matrix has the same data as arr1"
+
+      # Both arr1 and r_matrix point to the same backing store as seen above.
+
+      # Now, changing the r_matrix dimension will create a new r_matrix and arr1 and 
+      # r_matrix will now point to different backstores.  By design, any changes in a Renjin 
+      # object actually creates a new object.
+      r_matrix.attr.dim = R.c(4, 3)
+      p "just by setting the dimension, even with the same values as before, creates a new object"
+      r_matrix.pp
+
+      # changing the value of arr1 will have no impact in r_matrix
+      arr1[1, 1] = 1000.34
+      p "changing arr1 element will not change r_matrix element anymore"
+      arr1.print
+      p "r_matrix is unchanged"
+      r_matrix.pp
+
+      compare = MDArray.byte([4,3])
+      (0..3).each do |row|
+        (0..2).each do |col|
+          compare[row, col] = (arr1[row, col] == (r_matrix[row + 1, col + 1].gz))? 1 : 0
+        end
+      end
+      comp = R.md(compare)
+      assert_equal(false, comp.all.gt)
+
+    end
+
+  end
+  
+end

data/test/test_assign_mdarray_3d.rb

@@ -0,0 +1,201 @@
+# -*- 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 3D MDArray onto a R matrix" do
+
+      # create a 1D MDArray
+      arr1 = MDArray.typed_arange("double", 12)
+      arr1.reshape!([3, 2, 2])
+      
+      # Dimensions definitions are treated differently between MDArray and R. In MDArray
+      # a [3, 2, 2] specification indicates that there are 3 vector of 2 x 2 dimensions.
+      # So arr1 is the following array:
+      # [[[0.0 1.0]
+      #   [2.0 3.0]]
+      #
+      #  [[4.0 5.0]
+      #   [6.0 7.0]]
+      #
+      #  [[8.0 9.0]
+      #   [10.0 11.0]]]
+      # 
+      # in R the same specification indicates that we have two vectors each of 3 x 2. So,
+      # this would be the vector with the same [3, 2, 2] specification.
+      #      [,1] [,2]
+      # [1,]    1    2
+      # [2,]    3    4
+      # [3,]    5    6
+      #
+      # , , 2
+      #
+      #      [,1] [,2]
+      # [1,]    7   8
+      # [2,]    9   10
+      # [3,]    11  12
+      #
+      # When converting a multi-dimensional array from MDArray to R, SciCom also fixes
+      # the vector specification and the [3, 2, 2] MDArray specification becomes a 
+      # [2, 2, 3] R vector specification.
+      # In general converting from MDArray index to R index is done as follows: 
+      # Let [i1, i2, i3, ... in] be the MDArray index, the corresponding R index is 
+      # [i(n-1)+1, in+1, ..., i3+1, i2+1, i1+1].
+
+      # convert to an R matrix
+      r_matrix = R.md(arr1)
+
+      # Renjin does not yet print correctly N > 2 dimensional vectors
+      p "this is a 3D vector, but Renjin has a bug and prints it as a 1D vector"
+      r_matrix.pp
+
+      # In order to simplify access to the R vector with different dimension specification
+      # SciCom implements method 'ri' (r-indexing), so that arr1[dim1, dim2, dim3] is
+      # equal to r_matrix.ri(dim1, dim2, dim3)
+
+      compare = MDArray.byte(arr1.shape)
+      arr1.get_index.each do |ct|
+        compare[*ct] = (arr1[*ct] == (r_matrix.ri(*ct).gz))? 1 : 0
+      end
+      comp = R.md(compare)
+      assert_equal(true, comp.all.gt)
+
+      p "dimension of r_matrix in R"
+      R.vec = r_matrix
+      R.eval("print(dim(vec))")
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "work with MDArray slices" do
+
+      # create a 3D MDArray
+      # [[[0.0 1.0]
+      #   [2.0 3.0]]
+      #
+      #  [[4.0 5.0]
+      #   [6.0 7.0]]
+      #
+      #  [[8.0 9.0]
+      #   [10.0 11.0]]]
+      arr1 = MDArray.typed_arange("double", 12)
+      arr1.reshape!([3, 2, 2])
+      arr1.print
+
+      # This array has 3 vectors of size 2 x 2.  Getting slice(0, 0) returns the first
+      # 2 x 2 vector.
+      # [[0.0 1.0]
+      #  [2.0 3.0]]
+      p "slice(0, 0): this is a 2D slice of the original array"
+      mat = arr1.slice(0, 0)
+
+      # MDArray will be converted to the following R matrix
+      #      [,1] [,2]
+      # [1,]    0    1
+      # [2,]    2    3
+      p "now converting the slice into an R matrix"
+      r_mat = R.md(mat)
+
+      # Compare mat and r_mat
+      compare = MDArray.byte(mat.shape)
+      mat.get_index.each do |ct|
+        compare[*ct] = (mat[*ct] == (r_mat.ri(*ct).gz))? 1 : 0
+      end
+      comp = R.md(compare)
+      assert_equal(true, comp.all.gt)
+
+
+      # Getting slice(0, 2) returns the third 2 x 2 vector.
+      # [[8.0 9.0]
+      #  [10.0 11.0]]
+      p "slice(0, 2): this is a 2D slice of the original array"
+      mat = arr1.slice(0, 2)
+
+      #      [,1] [,2]
+      # [1,]    8    9
+      # [2,]   10   11
+      p "now converting the slice into an R matrix"
+      r_mat = R.md(mat)
+
+      # Compare mat and r_mat
+      compare = MDArray.byte(mat.shape)
+      mat.get_index.each do |ct|
+        compare[*ct] = (mat[*ct] == (r_mat.ri(*ct).gz))? 1 : 0
+      end
+      comp = R.md(compare)
+      assert_equal(true, comp.all.gt)
+
+      # slice(1, 0) gets the first row of all three vectors and thus returns a 3 x 2
+      # vector:
+      # [[0.0 1.0]
+      #  [4.0 5.0]
+      #  [8.0 9.0]]
+      p "slice(1, 0): this is a 2D slice of the original array"
+      mat = arr1.slice(1, 0)
+
+      # The above will become the following R matrix
+      #      [,1] [,2]
+      # [1,]    0    1
+      # [2,]    4    5
+      # [3,]    8    9
+      p "now converting the slice into an R matrix"
+      r_mat = R.md(mat)
+
+      compare = MDArray.byte(mat.shape)
+      mat.get_index.each do |ct|
+        compare[*ct] = (mat[*ct] == (r_mat.ri(*ct).gz))? 1 : 0
+      end
+      comp = R.md(compare)
+      assert_equal(true, comp.all.gt)
+
+      # Note that there is no data copying when an MDArray is sliced and this is an 
+      # efficient operation.
+
+    end
+
+  end
+  
+end
+

data/{lib/JRubyR/sequence.rb → test/test_assign_mdarray_4d.rb}

@@ -1,8 +1,6 @@
 # -*- 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 
@@ -21,36 +19,52 @@
 # OR MODIFICATIONS.
 ##########################################################################################
 
-require 'java'
+require 'rubygems'
+require "test/unit"
+require 'shoulda'
 
-class Renjin
+require 'env'
+require 'scicom'
 
-  class Sequence < Renjin::RubySexp
-    include Renjin::Index
-    
-  end
+class SciComTest < Test::Unit::TestCase
 
-end
+  context "R environment" do
 
-=begin
-#==========================================================================================
-#
-#==========================================================================================
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
 
-class Renjin
+    end
 
-  class IntSequence < Renjin::Sequence
-    include_package "org.renjin.primitives.sequence"
 
-    #----------------------------------------------------------------------------------------
+=begin    
+    #--------------------------------------------------------------------------------------
     #
-    #----------------------------------------------------------------------------------------
-    
-    def getElement(index)
-      @sexp.getElementAsInt(index)
+    #--------------------------------------------------------------------------------------
+
+    should "work with MDArray slices" do
+
+      dim = [6, 4, 3, 2]
+
+      # create a 1D MDArray
+      arr1 = MDArray.typed_arange(:double, dim.inject(:*))
+      arr1.reshape!(dim)
+      
+      slice = arr1.slice(0, 0)
+      slice.print
+      mat = R.md(slice)
+      mat.pp
+
+      slice = arr1.slice(0, 1)
+      slice.print
+      mat = R.md(slice)
+      mat.pp
+
     end
-    
+=end    
   end
-
+  
 end
-=end
+

data/test/test_complete.rb

@@ -39,10 +39,13 @@ require_relative 'test_matrix'
 require_relative 'test_dataframe'
 require_relative 'test_linear_model'
 
+require_relative 'test_assign_mdarray'
+require_relative 'test_assign_mdarray_2d'
+require_relative 'test_assign_mdarray_3d'
+
 =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'