scicom 0.2.2-java → 0.2.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bbab837d32391c045fed488fb94dc4266ac053e
-  data.tar.gz: 83b960cefd853e6e402681d0828cda5f1ae2d55a
+  metadata.gz: 9aef59cac8c877c6ed3e85aba23bf0157f51212a
+  data.tar.gz: f319a45282a3ca6639a0af0ac5dd9d9166298a3c
 SHA512:
-  metadata.gz: 039aaeca442751ce410213b5608c76ecc60791efc242ce425005576d7d58813b2d531b265f9c40cc8c2f8c304ea54e8dc7fb098f436dbc37256d7897ad24b2a4
-  data.tar.gz: 7cfc64064cd69ad58c61c965d4d9eb10d331340a561d871ae6414dfe0cd180835ca5c2160fb23ba6c0924ca5d9eb06f7b051a11613d9a1aa4ea85f6dc222192f
+  metadata.gz: 1ebfea9adeb89cd56730b443f15698b7787877f9c5503354750f558e68fc3942701f385d3eb9d07b05e7fde9ec118451394c4cfb60b873260de091f8bd7f5aa6
+  data.tar.gz: f5596e54636c345a2d1d7f10abf6e7284d5923611d693f93d1fd808ee0c09e7320d8c8bf623936ff4bf3b9a1bb664aae7744d186dd69bf2b9f6e0beb7df34330

data/README.md

@@ -41,7 +41,12 @@ Renjin is in development and still has some limitations
   hope that this limitation will be solved not by implementing those libraries but by the
   use of Ruby libraries from SciRuby such as NyaPlot (https://github.com/domitry/nyaplot) 
   or daru (https://github.com/v0dro/daru).
-  
+
+What´s new:
+===========
+
+This version includes integration of MDArray and SciCom. 
+
 
 SciCom installation and download:
 ==================================
@@ -62,7 +67,8 @@ Contributors are welcome.
 SciCom History:
 ================
 
-  + 19/11/2014: Version 0.2.2 - Printing in Jirb
-  + 17/11/2014: Version 0.2.1 - Added MDArray dependency
-  + 17/11/2014: Version 0.2.0 - Most R functionality available to SciCom	
-  + 21/06/2014: Version 0.0.1 - Initial release
+  + 30/Dec/2014: Version 0.2.3 - Integration with MDArray
+  + 19/Nov/2014: Version 0.2.2 - Printing in Jirb
+  + 17/Nov/2014: Version 0.2.1 - Added MDArray dependency
+  + 17/Nov/2014: Version 0.2.0 - Most R functionality available to SciCom	
+  + 21/Jul/2014: Version 0.0.1 - Initial release

data/config.rb

@@ -108,7 +108,7 @@ class SciCom
   @build_dir = SciCom.src_dir + "/build"
 
   class << self
-    attr_reader :build_dir
+    attr_accessor :build_dir
   end
 
   @classes_dir = SciCom.build_dir + "/classes"

data/lib/JRubyR/rbsexp.rb

@@ -222,8 +222,8 @@ class Renjin
     #----------------------------------------------------------------------------------------
     
     def print
-      Kernel.print(Java::OrgRenjinPrimitives::Print.doPrint(sexp))
-      # R.eval("print(#{r})")
+      # Kernel.print(Java::OrgRenjinPrimitives::Print.doPrint(sexp))
+      R.eval("print(#{r})")
     end
     
     #----------------------------------------------------------------------------------------
@@ -254,14 +254,6 @@ class Renjin
   
 end
 
-#==========================================================================================
-# Make a Ruby Array into a RBSexp
-#==========================================================================================
-
-class Array
-  include Renjin::RBSexp
-end
-
 #==========================================================================================
 #
 #==========================================================================================
@@ -305,9 +297,7 @@ class Renjin
     
     def self.build(sexp)
       
-      if (sexp.instance_of? Java::OrgRenjinPrimitivesSequence::IntSequence)
-        res = Renjin::Sequence.new(sexp)
-      elsif (sexp.instance_of? Java::OrgRenjinSexp::Null)
+      if (sexp.instance_of? Java::OrgRenjinSexp::Null)
         res = nil
       elsif (sexp.instance_of? Java::OrgRenjinSexp::ListVector)
         res = Renjin::List.new(sexp)
@@ -339,49 +329,7 @@ end
 
 require_relative 'ruby_classes'
 require_relative 'vector'
-require_relative 'sequence'
 require_relative 'list'
 require_relative 'function'
 require_relative 'logical_value'
 require_relative 'environment'
-
-
-=begin    
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-    
-    def set_sexp(sexp)
-      @sexp = sexp
-    end
-
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def method_missing(symbol, *args)
-      
-      name = symbol.id2name
-      name.gsub!(/__/,".")
-      
-      # super if args.length != 0
-      if name =~ /(.*)=$/
-        super if args.length != 1
-        args = R.parse(*args)
-        ret = R.eval("#{r}[[\"#{name}\"]] = #{args}")
-      elsif (args.length == 0)
-        # treat name as a named item of the list
-        ret = R.eval("#{r}[[\"#{name}\"]]")
-      elsif (name == "_")
-        method = "%#{args.shift.to_s}%"
-        arg2 = R.parse(*args)
-        ret = R.eval("#{r} #{method} #{arg2}")
-      else
-        raise "Illegal argument for named list item #{name}"
-      end
-      
-      ret
-      
-    end
-
-=end

data/lib/JRubyR/renjin.rb

@@ -25,7 +25,16 @@ require 'java'
 require 'securerandom'
 
 require_relative 'rbsexp'
-require_relative 'index'
+# require_relative 'index'
+
+
+#==========================================================================================
+#
+#==========================================================================================
+
+class Java::RbScicom::MDDoubleVector
+  field_reader :_array
+end
 
 
 #==========================================================================================
@@ -91,22 +100,6 @@ class Renjin
     
   end
 
-  #----------------------------------------------------------------------------------------
-  # Converts an MDArray shape or index onto an equivalent R shape or index
-  #----------------------------------------------------------------------------------------
-
-  def ri(shape)
-
-    rshape = shape.clone
-
-    if (rshape.size > 2)
-      rshape.reverse!
-      rshape[0], rshape[1] = rshape[1], rshape[0]
-    end
-    rshape.map{ |val| (val + 1) }
-
-  end
-
   #----------------------------------------------------------------------------------------
   #
   #----------------------------------------------------------------------------------------
@@ -171,33 +164,38 @@ class Renjin
   #----------------------------------------------------------------------------------------
 
   def pi
-    R.eval("pi")
+    eval("pi")
   end
 
   def LETTERS
-    R.eval("LETTERS")
+    eval("LETTERS")
   end
 
   def letters
-    R.eval("letters")
+    eval("letters")
   end
 
   def month__abb
-    R.eval("month.abb")
+    eval("month.abb")
   end
 
   def month__name
-    R.eval("month.name")
+    eval("month.name")
   end
 
   def i(value)
-    R.eval("#{value}L")
+    eval("#{value}L")
   end
 
   def d(value)
-    R.eval("#{value}")
+    eval("#{value}")
+  end
+
+  def md(value)
+    Renjin::Vector.new(build_vector(value))
   end
 
+
   #----------------------------------------------------------------------------------------
   #
   #----------------------------------------------------------------------------------------
@@ -385,23 +383,31 @@ class Renjin
       params = function[:params]
       function = function[:f]
       if (index)
-        R.eval("#{function.to_s}(#{sexp.r})#{index} = #{value.r}")
+        eval("#{function.to_s}(#{sexp.r})#{index} = #{value.r}")
       else
       end
     else
-      R.eval("#{function.to_s}(#{sexp.r}) = #{value.r}")
+      eval("#{function.to_s}(#{sexp.r}) = #{value.r}")
     end
 
+    sexp
+
   end
 
+  #----------------------------------------------------------------------------------------
+  # Builds a Renjin vector from an MDArray. Should be private, but public for testing.
+  #----------------------------------------------------------------------------------------
+
+  # private
+
   #----------------------------------------------------------------------------------------
   # Builds a Renjin vector from an MDArray. Should be private, but public for testing.
   #----------------------------------------------------------------------------------------
   
-  def build_vector(array)
+  def build_vector(mdarray)
     
-    shape = array.shape
-    index = array.nc_array.getIndex()
+    shape = mdarray.shape
+    # index = mdarray.nc_array.getIndex()
     # index = MDArray.index_factory(shape)
     # representation of shape in R is different from shape in MDArray.  Convert MDArray
     # shape to R shape.
@@ -409,12 +415,30 @@ class Renjin
       shape.reverse!
       shape[0], shape[1] = shape[1], shape[0]
     end
+
     # AttributeMap attributes = AttributeMap.builder().setDim(new IntVector(dim)).build();
     attributes = Java::OrgRenjinSexp::AttributeMap.builder()
       .setDim(Java::OrgRenjinSexp::IntArrayVector.new(*(shape))).build()
-    vector = Java::RbScicom::MDDoubleVector.new(array.nc_array, attributes, index,
-                                                index.stride)
+
+    # vector = Java::RbScicom::MDDoubleVector.new(mdarray.nc_array, attributes, index,
+    #   index.stride)
     
+    case mdarray.type
+    when "int"
+      vector = Java::RbScicom::MDIntVector.factory(mdarray.nc_array, attributes)
+    when "double"
+      vector = Java::RbScicom::MDDoubleVector.factory(mdarray.nc_array, attributes)
+    when "byte"
+      vector = Java::RbScicom::MDLogicalVector.factory(mdarray.nc_array, attributes)
+    when "string"
+      vector = Java::RbScicom::MDStringVector.factory(mdarray.nc_array, attributes)
+    when "boolean"
+      raise "Boolean vectors cannot be converted to R vectors.  If you are trying to \
+convert to an R Logical object, use a :byte MDArray"
+    else
+      raise "Cannot convert MDArray #{mdarray.type} to R vector"
+    end
+
   end
 
 

data/lib/JRubyR/ruby_classes.rb

@@ -54,5 +54,12 @@ end
 
 class Array
   include Renjin::RBSexp
+end
+
+#==========================================================================================
+#
+#==========================================================================================
 
+class MDArray
+  include Renjin::RBSexp
 end

data/lib/JRubyR/vector.rb

@@ -192,6 +192,23 @@ class Renjin
       
     end
     
+    #----------------------------------------------------------------------------------------
+    # Converts an MDArray shape or index onto an equivalent R shape or index
+    #----------------------------------------------------------------------------------------
+    
+    def ri(*shape)
+      
+      rshape = shape.clone
+      
+      if (rshape.size > 2)
+        rshape.reverse!
+        rshape[0], rshape[1] = rshape[1], rshape[0]
+      end
+      rshape.map!{ |val| (val + 1) }
+      self[*rshape]
+      
+    end
+
     #----------------------------------------------------------------------------------------
     #
     #----------------------------------------------------------------------------------------

data/test/env.rb

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

data/test/test_R_interface.rb

@@ -73,6 +73,7 @@ class SciComTest < Test::Unit::TestCase
       # Using method assign, to assign NULL to variable 'null' in R namespace.
       R.assign("null", nil)
       assert_equal(nil, R.null)
+      R.eval("print(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.

data/test/test_assign_mdarray.rb

@@ -0,0 +1,128 @@
+# -*- 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 'benchmark'
+
+require 'env'
+require 'scicom'
+
+class SciComTest < Test::Unit::TestCase
+
+  context "R environment" do
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "convert MDArrays to R arrays" do
+
+      #--------------------------------------------------------------------------------------
+      #
+      #--------------------------------------------------------------------------------------
+
+      def to_r(dim, type)
+
+        dims = Array.new
+        (0...dim).each do |s|
+          dims[s] = rand(1..8)
+        end
+
+        p "converting MDArray of shape #{dims} and type #{type} to R array"
+
+        case type
+        when :byte
+          arr1 = MDArray.byte(dims)
+        when :rstring
+          arr1 = MDArray.init_with("rstring", dims, "this is a string")
+        else
+          arr1 = MDArray.typed_arange(type.to_s, dims.inject(:*))
+        end
+        
+        arr1.reshape!(dims)
+
+        # convert to an R matrix
+        r_matrix = R.md(arr1)
+
+        # only compare all elements if array size is less than 5.  For larger arrays this will take 
+        # too much time.
+        if (dims.size < 6)
+          # A byte MDArray is converted to a Logical vector in R.  Boolean MDArrays cannot be 
+          # converted to logical vectors efficiently in Renjin.
+          compare = MDArray.byte(dims)
+          
+          # 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)
+          arr1.get_index.each do |ct|
+            compare[*ct] = (arr1[*ct] == (r_matrix.ri(*ct).gz))? 1 : 0
+          end
+          
+          # Convert the byte MDArray to an R vector.
+          comp = R.md(compare)
+          # use the .all method from R to verify that all elements in the vector all TRUE
+          assert_equal(true, comp.all.gt)
+        end
+        
+      end
+
+      #--------------------------------------------------------------------------------------
+      # Check conversion of 5 different arrays for dimensions from 1 to 7 (which are 
+      # optimized) and also for 8 to 10 dimensions (that are not optimized)
+      #--------------------------------------------------------------------------------------
+
+      
+      [:char, :long, :float].each do |type|
+        # convert to an R matrix
+        arr1 = MDArray.build(type, [2])
+        assert_raise ( RuntimeError ) { r_matrix = R.md(arr1) }
+      end
+      
+      #--------------------------------------------------------------------------------------
+      # Check conversion of 5 different arrays for dimensions from 1 to 7 (which are 
+      # optimized) and also for 8 to 10 dimensions (that are not optimized)
+      #--------------------------------------------------------------------------------------
+
+#  
+
+      [:byte, :int, :double, :rstring].each do |type|
+        (1..9).each do |dim|
+          (0...2).each do
+            to_r(dim, type)
+          end
+        end
+      end
+
+    end
+
+  end
+  
+end