scicom 0.4.0-java → 0.4.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ffc1bffa5d865e5df2c6843e4b016b34f283209
-  data.tar.gz: 362146cc4e463467e0d90c1758255c0bc97b9f9a
+  metadata.gz: 33c8efc122762f2a26802e9bf733cbb323817cb8
+  data.tar.gz: 1b4cf240792f14589d49525be0d5aea96ff9469e
 SHA512:
-  metadata.gz: f8d3a2b9b0d447b888b3cef294b21de6f085a5f199f38c7a295234b4eb02c8c32abcbb1ba6d42cbdac65f6b79e630ed7051836b64008f75779296378c3d63874
-  data.tar.gz: 1b7717cec680c29aa20579f7d4d62a37e3965272bcaadbf99d8c6563e833b873a6141b739283186c286e45127fcceb3c4a6ac98308f1063d7bccf111f7cdacde
+  metadata.gz: ea9e5b93ecd6f1e34c0328fa851ba08eb4b0475876161a69ff562b744c9aba990b5f5dd590f6797dd59ea33024203ec28e8d1286a5d1d69e1d5ed2ebed209490
+  data.tar.gz: abd5d25b94e18557133d15bec9f840896b6c11410dd1fc82a6700dc557918bcfd61f28aab8efa035e993f03c86df6838324fdf57603325ea0c6afe2147056b81

data/README.md

@@ -1,68 +1,3 @@
-## SciCom with Standard R Interface
-
-SciCom allows R programmers to use R commands inside a Ruby script in
-a way similar to RinRuby by calling method eval and passing to it an R
-script:
-
-    # Basic integration with R can always be done by calling eval and passing it a valid
-    # R expression.
-    > R.eval("r.i = 10L")
-    > R.eval("print(r.i)")
-
-    [1] 10
-
-    > R.eval("vec = c(10, 20, 30, 40, 50)")
-    > R.eval("print(vec)")
-
-    [1] 10 20 30 40 50
-
-    > R.eval("print(vec[1])")
-
-    [1] 10
-
-Programmers can also use here docs to integrate an R script inside a
-Ruby script.  The next example show a model for predicting baseball
-wins based on runs allowed and runs scored.  The data comes from
-Baseball-Reference.com.
-
-      R.eval <<EOF
-
-        # This dataset comes from Baseball-Reference.com.
-        baseball = read.csv("baseball.csv")
-        # str has a bug in Renjin
-        # str(data)
-
-        # Lets look at the data available for Momeyball.
-        moneyball = subset(baseball, Year < 2002)
-
-        # Let's see if we can predict the number of wins, by lookin at
-        # runs allowed (RA) and runs scored (RS).  RD is the runs difference.
-        # We are making a linear model from predicting wins (W) based on RD
-        moneyball$RD = moneyball$RS - moneyball$RA
-        WinsReg = lm(W ~ RD, data=moneyball)
-        print(summary(WinsReg))
-
-    EOF
-
-The output of the program above is:
-
-    Call:
-    lm(data = moneyball, formula = W ~ RD)
-
-    Residuals:
-        Min      1Q  Median      3Q     Max
-    -14,266  -2,651   0,123   2,936  11,657
-
-    Coefficients:
-                Estimate   Std. Error t value    Pr(>|t|)             
-    (Intercept) 80,881     0,131      616,675    <0         ***       
-             RD 0,106      0,001       81,554    <0         ***       
-    ---
-    Signif. codes:  0 '***' 0,001 '**' 0,01 '*' 0,05 '.' 0,1 ' ' 1 
-
-    Residual standard error: 3,939 on 900 degrees of freedom
-    Multiple R-squared: 0,8808,	Adjusted R-squared: 0,8807 
-    F-statistic: 6.650,9926 on 1 and 900 DF,  p-value: < 0
 
 ## The SciCom “language”
 
@@ -256,3 +191,68 @@ Ruby hashes in the normal Ruby way.
 
 	[0.0+1.0i]
 
+## SciCom with Standard R Interface
+
+SciCom allows R programmers to use R commands inside a Ruby script in
+a way similar to RinRuby by calling method eval and passing to it an R
+script:
+
+    # Basic integration with R can always be done by calling eval and passing it a valid
+    # R expression.
+    > R.eval("r.i = 10L")
+    > R.eval("print(r.i)")
+
+    [1] 10
+
+    > R.eval("vec = c(10, 20, 30, 40, 50)")
+    > R.eval("print(vec)")
+
+    [1] 10 20 30 40 50
+
+    > R.eval("print(vec[1])")
+
+    [1] 10
+
+Programmers can also use here docs to integrate an R script inside a
+Ruby script.  The next example show a model for predicting baseball
+wins based on runs allowed and runs scored.  The data comes from
+Baseball-Reference.com.
+
+      R.eval <<EOF
+
+        # This dataset comes from Baseball-Reference.com.
+        baseball = read.csv("baseball.csv")
+        # str has a bug in Renjin
+        # str(data)
+
+        # Lets look at the data available for Momeyball.
+        moneyball = subset(baseball, Year < 2002)
+
+        # Let's see if we can predict the number of wins, by lookin at
+        # runs allowed (RA) and runs scored (RS).  RD is the runs difference.
+        # We are making a linear model from predicting wins (W) based on RD
+        moneyball$RD = moneyball$RS - moneyball$RA
+        WinsReg = lm(W ~ RD, data=moneyball)
+        print(summary(WinsReg))
+
+    EOF
+
+The output of the program above is:
+
+    Call:
+    lm(data = moneyball, formula = W ~ RD)
+
+    Residuals:
+        Min      1Q  Median      3Q     Max
+    -14,266  -2,651   0,123   2,936  11,657
+
+    Coefficients:
+                Estimate   Std. Error t value    Pr(>|t|)             
+    (Intercept) 80,881     0,131      616,675    <0         ***       
+             RD 0,106      0,001       81,554    <0         ***       
+    ---
+    Signif. codes:  0 '***' 0,001 '**' 0,01 '*' 0,05 '.' 0,1 ' ' 1 
+
+    Residual standard error: 3,939 on 900 degrees of freedom
+    Multiple R-squared: 0,8808,	Adjusted R-squared: 0,8807 
+    F-statistic: 6.650,9926 on 1 and 900 DF,  p-value: < 0

data/lib/JRubyR/rbsexp.rb

@@ -38,6 +38,7 @@ class Renjin
     include_package "java.lang"
     
     attr_reader :sexp
+    attr_reader :refresh
     attr_reader :rvar
     attr_reader :attr
     attr_accessor :scope
@@ -75,8 +76,15 @@ class Renjin
         @rvar = "sc_#{SecureRandom.hex(8)}"
         
         # if this object already has a sexp value then assign to @rvar the existing sexp,
-        # otherwise, assign itself to @rvar.
-        (@sexp == nil)? R.assign(@rvar, self) : R.assign(@rvar, @sexp)
+        # otherwise, assign itself to @rvar.  If a sexp already exists then set the
+        # refresh flag to true, so that we know that the sexp was changed.
+        # (@sexp == nil)? R.assign(@rvar, self) : R.assign(@rvar, @sexp)
+        if (@sexp.nil?)
+          R.assign(@rvar, self)
+        else
+          @refresh = true
+          R.assign(@rvar, @sexp)
+        end
         
         # Whenever a variable is injected in Renjin, it is also added to the Renjin stack.
         # After eval, every injected variable is removed from Renjin making sure that we
@@ -160,6 +168,7 @@ class Renjin
       @sexp = sexp
       @rvar = nil
       @attr = Attributes.new(self)
+      @refresh = false
 
     end
     

data/lib/JRubyR/renjin.rb

@@ -260,7 +260,9 @@ class Renjin
   end
 
   #----------------------------------------------------------------------------------------
-  #
+  # Every time eval is called, a new Renjin::RubySexp is build.  If we don't want to wrap
+  # the returned value of an evaluation in a RubySexp, then method direct_eval should be
+  # called.
   #----------------------------------------------------------------------------------------
 
   def eval(expression)
@@ -334,7 +336,9 @@ class Renjin
         params << "(#{arg.begin}:#{final_value})"
       elsif (arg.is_a? Hash)
         arg.each_pair do |key, value|
-          params << "#{key.to_s} = #{parse(value)}"
+          # k = key.to_s.gsub(/__/,".")
+          params << "#{key.to_s.gsub(/__/,'.')} = #{parse(value)}"
+          # params << "#{k} = #{parse(value)}"
         end
       elsif ((arg.is_a? Renjin::RubySexp) || (arg.is_a? Array) || (arg.is_a? MDArray))
         params << arg.r
@@ -575,15 +579,15 @@ class Renjin
     #   index.stride)
     
     case mdarray.type
-    when "int"
+    when "int", :int
       vector = Java::RbScicom::MDIntVector.factory(mdarray.nc_array, attributes)
-    when "double"
+    when "double", :double
       vector = Java::RbScicom::MDDoubleVector.factory(mdarray.nc_array, attributes)
-    when "byte"
+    when "byte", :byte
       vector = Java::RbScicom::MDLogicalVector.factory(mdarray.nc_array, attributes)
-    when "string"
+    when "string", :string
       vector = Java::RbScicom::MDStringVector.factory(mdarray.nc_array, attributes)
-    when "boolean"
+    when "boolean", :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

data/lib/JRubyR/vector.rb

@@ -132,47 +132,19 @@ class Renjin
     def eq(other_val)
       (other_val == nil)? false : R.eval("identical(#{r},#{other_val.r})")
     end
-=begin
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def as__integer
-      R.as__integer(self)
-    end
-
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def as__double
-      R.as__double(self)
-    end
 
     #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def as__complex
-      R.as__complex(self)
-    end
-
-    #----------------------------------------------------------------------------------------
-    #
-    #----------------------------------------------------------------------------------------
-
-    def as__character
-      R.as__character(self)
-    end
-=end
-    #----------------------------------------------------------------------------------------
-    #
+    # Returns a sexp as an mdarray.
     #----------------------------------------------------------------------------------------
     
     def as__mdarray
 
-      if (@mdarray)
-      elsif (@sexp.java_kind_of? Java::RbScicom::MDDoubleVector)
+      if (@mdarray && !@refresh)
+        return @mdarray
+      end
+
+      @refresh = false
+      if (@sexp.java_kind_of? Java::RbScicom::MDDoubleVector)
         @mdarray = MDArray.build_from_nc_array(:double, @sexp.array)
       elsif (@sexp.java_kind_of? Java::OrgRenjinSexp::DoubleArrayVector)
         @mdarray = MDArray.from_jstorage("double", [@sexp.length()], @sexp.toDoubleArrayUnsafe())

data/test/test_assign_mdarray_2d.rb

@@ -56,7 +56,7 @@ MDArray to R"
 
       # change an element of the MDArray
       arr1[0, 0] = 10.34567
-      p "changing element is arr1 will cause the same change in r_matrix"
+      p "changing element in arr1 will cause the same change in r_matrix"
       arr1.print
 
       p "element [0, 0] of r_matrix has also changed"

data/test/test_complete.rb

@@ -36,8 +36,10 @@ require_relative 'test_attributes'
 require_relative 'test_factor'
 require_relative 'test_array'
 require_relative 'test_matrix'
+require_relative 'test_mdarray'
 require_relative 'test_dataframe'
 require_relative 'test_linear_model'
+require_relative 'test_callback'
 
 require_relative 'test_assign_mdarray'
 require_relative 'test_assign_mdarray_2d'

data/test/test_matrix.rb

@@ -27,7 +27,7 @@ require '../config' if @platform == nil
 require 'scicom'
 
 class SciComTest < Test::Unit::TestCase
-
+  
   context "R environment" do
 
     #--------------------------------------------------------------------------------------
@@ -41,7 +41,7 @@ class SciComTest < Test::Unit::TestCase
     #--------------------------------------------------------------------------------------
 
     setup do 
-      
+
     end
 
     #--------------------------------------------------------------------------------------
@@ -54,7 +54,7 @@ class SciComTest < Test::Unit::TestCase
       # fourth column, but it is useful to label the rows and columns to make the rows 
       # (subjects) and columns (variables) distinction more obvious.
       xij = R.matrix(R.seq(1..40), ncol: 4)
-      
+
       # method fassign is used whenever in R there would be a function assignment such as,
       # for example: rownames(x) <- c("v1", "v2", "v3")
       # R.fassign(xij, :rownames, R.paste("S", R.seq(1, xij.attr.dim[1]), sep: ""))
@@ -64,20 +64,20 @@ class SciComTest < Test::Unit::TestCase
       xij.fassign(:rownames, R.paste("S", R.seq(1, xij.attr.dim[1]), sep: ""))
       xij.fassign(:colnames, R.paste("V", R.seq(1, xij.attr.dim[2]), sep: ""))
       xij.pp
-
+      
       # if an index can be passed to the R function, then fassign needs to be a bit more
       # complex. For instance, callling dimnames(x)[[1]] <- "name" is done by the following
       # call: x.fassign({f: :dimnames, index:[[1]]}, "name"
       # Changing rownames by using function :dimnames and index [[1]]
       xij.fassign({f: :dimnames, index: [[1]]}, 
-        R.paste("DS", R.seq(1, xij.attr.dim[1]), sep: ""))
+                  R.paste("DS", R.seq(1, xij.attr.dim[1]), sep: ""))
 
       # Changing colnames by using function :dimnames and index [[2]]
       xij.fassign({f: :dimnames, index: [[2]]}, 
-        R.paste("DV", R.seq(1, xij.attr.dim[2]), sep: ""))
-
+                  R.paste("DV", R.seq(1, xij.attr.dim[2]), sep: ""))
+      
       xij.pp
-
+      
       # Just as the transpose of a vector makes a column vector into a row vector, so 
       # does the transpose of a matrix swap the rows for the columns. Note that now the 
       # subjects are columns and the variables are the rows.

data/test/test_mdarray.rb

@@ -23,7 +23,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
+require '../config' if @platform == nil
 require 'scicom'
 
 
@@ -39,46 +39,34 @@ class SciComTest < Test::Unit::TestCase
 
     end
 
-
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     should "convert a vector to an MDArray" do
 
+      r_vector = R.c(1, 2, 3, 4)
+
       # Method 'get' converts a Vector to an MDArray
-      vec = i3.get
+      vec = r_vector.get
       assert_equal(true, vec.is_a?(MDArray))
-      assert_equal("int", vec.type)
+      assert_equal("double", vec.type)
 
       # For consistancy with R notation one can also call as__mdarray to convert a 
       # vector to an MDArray
-      vec2 = i3.as__mdarray
+      vec2 = r_vector.as__mdarray
       assert_equal(true, vec2.is_a?(MDArray))
-      assert_equal("int", vec2.type)
+      assert_equal("double", 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
+      assert_equal(1, vec[0])
+      assert_equal(2, vec[1])
+      assert_equal(3, vec[2])
+      assert_equal(4, vec[3])
       
     end
 
-=begin
-
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
@@ -88,43 +76,53 @@ class SciComTest < Test::Unit::TestCase
       # 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.reshape!([5, 12])
       # arr.print
 
-      R.eval <<EOF
-      print(#{arr.r});
-      vec = #{arr.r};
-print(vec);
-print(vec[1, 1, 1]);
-
-EOF
+      R.eval <<-EOF
+        vec = #{arr.r};
+        print(vec);
+        print(vec[1, 1]);
+      EOF
 
-end
-=end
+    end
 
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     should "receive 1 Dimensional MDArrays in R" do
-      
+
+      # vec is an MDArray
       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
 
+      # prime is a R vector
       R.prime = vec
+      R.prime.pp
 
-      # now vec is immutable, since it is now in Renjin and Renjin requires an immutable
-      # vector
-      assert_raise ( RuntimeError ) { vec[0] = 1 }
+      # change the value of vec, the same change should happens in prime... they have the
+      # same backing store
+      vec[0] = 17
+      R.prime.pp
 
-      vec2 = R.eval("print(prime)")
-      vec2.print
+      # now r_vec is an R vector
+      r_vec = R.c(1, 3, 5, 7, 11, 13)
+      r_vec.pp
+      
+      # and prime is an MDArray
+      prime = r_vec.get
+      prime.print
 
-      assert_raise ( RuntimeError ) { vec2[1] = 7 }
+      # change the value of prime
+      prime[0] = 17
+      prime.print
+      
+      r_vec.pp
       
     end
 
+=begin
+
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
@@ -252,7 +250,7 @@ end
       R.eval("print(#{MDArray.typed_arange(:double, 5).r})")
 
     end
-
+=end
   end
-
+  
 end

data/version.rb

@@ -1,2 +1,2 @@
 $gem_name = "scicom"
-$version="0.4.0"
+$version="0.4.1"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scicom
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: java
 authors:
 - Rodrigo Botafogo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-03-03 00:00:00.000000000 Z
+date: 2016-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement