scicom 0.3.0-java → 0.4.0-java

data/lib/JRubyR/renjin.rb

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-
 ##########################################################################################
 # @author Rodrigo Botafogo
 #
@@ -21,13 +20,10 @@
 # OR MODIFICATIONS.
 ##########################################################################################
 
-require 'java'
 require 'securerandom'
 
 require_relative 'rbsexp'
-require_relative 'package'
-# require_relative 'index'
-
+# require_relative 'package'
 
 #==========================================================================================
 #
@@ -37,15 +33,57 @@ class Java::RbScicom::MDDoubleVector
   field_reader :_array
 end
 
-
 #==========================================================================================
 #
 #==========================================================================================
 
 class Renjin
-  include_package "javax.script"
-  include_package "org.renjin"
+  # include_package "javax.script"
+  # include_package "org.renjin"
+  # include_package "org.renjin.aether"
+  include_package "org.renjin.script"
+  
+  java_import "org.renjin.eval.SessionBuilder"
+  java_import "org.renjin.primitives.packaging.PackageLoader"
+  java_import "org.renjin.aether.AetherPackageLoader"
+
+  #========================================================================================
+  # Class Writer is necessary if we want to redirect the standard output or standar err
+  # to a Ruby String for futher processing after a Renjin script evaluation.  As can be
+  # seen this class requires improvements, but it is functional
+  #========================================================================================
+  
+  class Writer < Java::JavaIo.Writer
 
+    attr_reader :string
+    
+    def initialize(buffer)
+      @string = buffer
+    end
+    
+    def write(string, offset, len)
+      @string << string
+      $stdout.pos = @string.length
+    end
+    
+    def flush
+      
+    end
+    
+    def close
+      
+    end
+    
+    def output
+      puts @string
+    end
+    
+  end
+  
+  #========================================================================================
+  #
+  #========================================================================================
+  
   @stack = Array.new
 
   class << self
@@ -80,24 +118,18 @@ class Renjin
 
   def initialize
 
-    @platform = 
-      case RUBY_PLATFORM
-      when /mswin/ then 'windows'
-      when /mingw/ then 'windows'
-      when /bccwin/ then 'windows'
-      when /cygwin/ then 'windows-cygwin'
-      when /java/
-        require 'java' #:nodoc:
-        if java.lang.System.getProperty("os.name") =~ /[Ww]indows/
-          'windows-java'
-        else
-          'default-java'
-        end
-      else 'default'
-      end
+    @session = SessionBuilder.new
+               .bind(PackageLoader.java_class, AetherPackageLoader.new)
+               .withDefaultPackages
+               .build
+    @engine = RenjinScriptEngineFactory.new.getScriptEngine(@session);
 
-    factory = Java::JavaxScript.ScriptEngineManager.new()
-    @engine = factory.getEngineByName("Renjin")
+    @default_std_out = @session.getStdOut()
+    @default_std_err = @session.connectionTable.getStderr()
+    
+    # factory = Java::JavaxScript.ScriptEngineManager.new()
+    # @engine = factory.getEngineByName("Renjin")
+    raise "Renjin not found. Please check your CLASSPATH: #{$CLASSPATH}" if @engine == nil
     super
 
   end
@@ -106,6 +138,70 @@ class Renjin
   #
   #----------------------------------------------------------------------------------------
 
+  def set_std_out(buffer)
+
+    $stdout = StringIO.new(buffer)
+    @alternate_out = Writer.new(buffer)
+    print_writer = Java::JavaIo::PrintWriter.new(@alternate_out)
+    @session.setStdOut(print_writer)
+    self
+    
+  end
+  
+  #----------------------------------------------------------------------------------------
+  #
+  #----------------------------------------------------------------------------------------
+
+  def alternate_out
+    @alternate_out.string
+  end
+  
+  #----------------------------------------------------------------------------------------
+  #
+  #----------------------------------------------------------------------------------------
+
+  def set_std_err(buffer)
+
+    $stderr = StringIO.new(buffer)
+    @alternate_err = Writer.new(buffer)
+    print_writer = Java::JavaIo::PrintWriter.new(@alternate_err)
+    @session.setStdErr(print_writer)
+    self
+    
+  end
+
+  #----------------------------------------------------------------------------------------
+  #
+  #----------------------------------------------------------------------------------------
+
+  def alternate_err
+    @alternate_err.string
+  end
+
+  #----------------------------------------------------------------------------------------
+  #
+  #----------------------------------------------------------------------------------------
+
+  def set_default_std_out
+    
+    $stdout = STDOUT
+    @session.setStdOut(@default_std_out)
+    
+  end
+
+  #----------------------------------------------------------------------------------------
+  #
+  #----------------------------------------------------------------------------------------
+
+  def set_default_std_err
+    $stderr = STDERR
+    @session.setStdErr(@default_std_err)
+  end
+  
+  #----------------------------------------------------------------------------------------
+  #
+  #----------------------------------------------------------------------------------------
+
   def nan?(x)
     is__nan(x)
   end
@@ -130,7 +226,11 @@ class Renjin
   end
 
   #----------------------------------------------------------------------------------------
-  #
+  # When calling a R.<id>, we will call method_missing.  This can be an assignment:
+  # R.name = <value>, can be a variable access: puts R.name, a call to a function without
+  # arguments R.<function> or a function with arguments. If it is a call to a function
+  # with arguments, then all arguments need to be parsed (and converted to R) and then
+  # the function is called.
   #----------------------------------------------------------------------------------------
 
   def method_missing(symbol, *args)
@@ -142,10 +242,8 @@ class Renjin
     name.gsub!("rclass", "class")
 
     if name =~ /(.*)=$/
-      super if args.length != 1
       ret = assign($1,args[0])
     else
-      # super if args.length != 0
       if (args.length == 0)
         # is_var = false
         # Try to see if name is a variable or a method.
@@ -161,43 +259,6 @@ class Renjin
 
   end
 
-  #----------------------------------------------------------------------------------------
-  # R built-in constants
-  #----------------------------------------------------------------------------------------
-
-  def pi
-    eval("pi")
-  end
-
-  def LETTERS
-    eval("LETTERS")
-  end
-
-  def letters
-    eval("letters")
-  end
-
-  def month__abb
-    eval("month.abb")
-  end
-
-  def month__name
-    eval("month.name")
-  end
-
-  def i(value)
-    eval("#{value}L")
-  end
-
-  def d(value)
-    eval("#{value}")
-  end
-
-  def md(value)
-    Renjin::Vector.new(build_vector(value))
-  end
-
-
   #----------------------------------------------------------------------------------------
   #
   #----------------------------------------------------------------------------------------
@@ -243,7 +304,8 @@ class Renjin
   end
 
   #----------------------------------------------------------------------------------------
-  #
+  # Parse an argument and returns a piece of R script needed to build a complete R
+  # statement.
   #----------------------------------------------------------------------------------------
 
   def parse(*args)
@@ -288,6 +350,15 @@ class Renjin
       
   end
 
+  #----------------------------------------------------------------------------------------
+  # Converts the given parameter into an R object.  If the parameter is already an R
+  # object, then leave it unchanged.
+  #----------------------------------------------------------------------------------------
+
+  def convert(param)
+    R.eval(parse(param))
+  end
+  
   #----------------------------------------------------------------------------------------
   # Data is copied from Ruby to R using the assign method or a short-hand equivalent. For 
   # example:
@@ -345,13 +416,16 @@ class Renjin
 
     original_value = value
 
-    if ((value.is_a? MDArray) || (value.is_a? RubySexp))
+    if ((value.is_a? MDArray)) # || (value.is_a? RubySexp))
       if (value.sexp != nil)
         # MDArray already represented in R
         value = value.sexp
       else
         value = build_vector(value)
       end
+    elsif (value.is_a? RubySexp)
+      # puts "I'm a Sexp: #{value} and value.sexp is #{value.sexp}"
+      value = value.sexp
     elsif (value == nil)
       value = NULL
     end
@@ -406,7 +480,7 @@ class Renjin
     pm.load_package(name)
 
   end
-
+=begin
   #----------------------------------------------------------------------------------------
   #
   #----------------------------------------------------------------------------------------
@@ -420,15 +494,65 @@ class Renjin
     eval("library(#{package})")
 
   end
+=end
 
   #----------------------------------------------------------------------------------------
-  # Builds a Renjin vector from an MDArray. Should be private, but public for testing.
+  # R built-in constants
   #----------------------------------------------------------------------------------------
 
-  # private
+  def pi
+    eval("pi")
+  end
+
+  def LETTERS
+    eval("LETTERS")
+  end
+
+  def letters
+    eval("letters")
+  end
+
+  def month__abb
+    eval("month.abb")
+  end
+
+  def month__name
+    eval("month.name")
+  end
+
+  def i(value)
+    eval("#{value}L")
+  end
+
+  def d(value)
+    eval("#{value}")
+  end
 
   #----------------------------------------------------------------------------------------
-  # Builds a Renjin vector from an MDArray. Should be private, but public for testing.
+  # Creates a new Renjin Vector based on an MDArray
+  #----------------------------------------------------------------------------------------
+
+  def md(value)
+    Renjin::Vector.new(build_vector(value))
+  end
+
+  #----------------------------------------------------------------------------------------
+  # Packs a ruby class inside a RBSexp, so that methods in the Ruby class can be called
+  # back from inside an R script
+  #----------------------------------------------------------------------------------------
+
+  def rpack(ruby_class, scope: :external)
+    Renjin::Callback.pack(ruby_class, scope: scope)
+  end
+
+  #----------------------------------------------------------------------------------------
+  #
+  #----------------------------------------------------------------------------------------
+
+  private
+
+  #----------------------------------------------------------------------------------------
+  # Builds a Renjin vector from an MDArray. 
   #----------------------------------------------------------------------------------------
   
   def build_vector(mdarray)
@@ -473,6 +597,8 @@ end
 
 # Create a new R interpreter
 R = Renjin.new
+
+# Add some constants to the R interpreter
 NA = R.eval("NA")
 NaN = R.eval("NaN")
 Inf = R.eval("Inf")
@@ -480,3 +606,7 @@ MInf = R.eval("-Inf")
 NULL = R.direct_eval("NULL")
 # EPSILON = R.eval("EPSILON")
 # NA_integer = R.eval("NA_integer")
+
+# create a R variable Ruby.Object that allow access to Ruby Object class
+R.Ruby__Object = Renjin::Callback.new(Object)
+

data/lib/JRubyR/vector.rb

@@ -21,8 +21,6 @@
 # OR MODIFICATIONS.
 ##########################################################################################
 
-require 'java'
-
 
 #==========================================================================================
 #
@@ -36,6 +34,9 @@ class Java::OrgRenjinSexp::LogicalArrayVector
   field_reader :values
 end
 
+class Java::OrgRenjinSexp::LongArrayVector
+  field_reader :values
+end
 
 #==========================================================================================
 #
@@ -64,7 +65,7 @@ class Renjin
     #----------------------------------------------------------------------------------------
 
     def integer?
-      R.is__integer(R.eval("#{r}")).gt
+      R.eval("#{r}").is__integer.gt
     end
 
     #----------------------------------------------------------------------------------------
@@ -131,7 +132,7 @@ class Renjin
     def eq(other_val)
       (other_val == nil)? false : R.eval("identical(#{r},#{other_val.r})")
     end
-
+=begin
     #----------------------------------------------------------------------------------------
     #
     #----------------------------------------------------------------------------------------
@@ -163,7 +164,7 @@ class Renjin
     def as__character
       R.as__character(self)
     end
-
+=end
     #----------------------------------------------------------------------------------------
     #
     #----------------------------------------------------------------------------------------
@@ -171,19 +172,20 @@ class Renjin
     def as__mdarray
 
       if (@mdarray)
-      elsif (@sexp.instance_of? Java::RbScicom::MDDoubleVector)
+      elsif (@sexp.java_kind_of? Java::RbScicom::MDDoubleVector)
         @mdarray = MDArray.build_from_nc_array(:double, @sexp.array)
-      elsif (@sexp.instance_of? Java::OrgRenjinSexp::DoubleArrayVector)
+      elsif (@sexp.java_kind_of? Java::OrgRenjinSexp::DoubleArrayVector)
         @mdarray = MDArray.from_jstorage("double", [@sexp.length()], @sexp.toDoubleArrayUnsafe())
-      elsif (@sexp.instance_of? Java::OrgRenjinSexp::IntArrayVector)
+      elsif (sexp.instance_of? Java::OrgRenjinSexp::LongArrayVector)
+        @mdarray = MDArray.from_jstorage("long", [@sexp.length()], @sexp.values)
+      elsif (@sexp.java_kind_of? Java::OrgRenjinSexp::IntArrayVector)
         @mdarray = MDArray.from_jstorage("int", [@sexp.length()], @sexp.toIntArrayUnsafe())
-      elsif (@sexp.instance_of? Java::OrgRenjinSexp::StringArrayVector)
+      elsif (@sexp.java_kind_of? Java::OrgRenjinSexp::StringArrayVector)
         @mdarray = MDArray.from_jstorage("string", [@sexp.length()], @sexp.values)
-      elsif (@sexp.instance_of? Java::OrgRenjinSexp::LogicalArrayVector)
+      elsif (@sexp.java_kind_of? Java::OrgRenjinSexp::LogicalArrayVector)
         @mdarray = MDArray.from_jstorage("int", [@sexp.length()], @sexp.values)
       else
-        p "sexp type needs to be specialized"
-        p @sexp
+        p "as__mdarray: sexp type needs to be specialized: #{@sexp}"
         @mdarray = Renjin::RubySexp.new(@sexp)
       end
       
@@ -258,7 +260,6 @@ class Renjin
         other_vec = R.d(other_vec)
       end
       R.eval("#{r} + #{other_vec.r}")
-
     end
 
     #----------------------------------------------------------------------------------------
@@ -385,11 +386,11 @@ class Renjin
     #----------------------------------------------------------------------------------------
     #
     #----------------------------------------------------------------------------------------
-
+=begin
     def !
       R.eval("!#{r}")
     end
-
+=end
     #----------------------------------------------------------------------------------------
     #
     #----------------------------------------------------------------------------------------