r_bridge 0.5.1 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 678aaf66ad022546771461a682f5dee6efa065402c8890197ac3e809cb491cda
-  data.tar.gz: 6e4c24a1f8fc85599707ca0aa7799a8b7ef7bfbb0fcb7e1f1cc720f58f179046
+  metadata.gz: ad1d735bada2b3edde78582804db6ed1c260663f59fb52e236adf678248b75d7
+  data.tar.gz: 619abe8dc2e78aa7fae3d20c68da7279a67b72a4fe934562e6ef8d613cadb14b
 SHA512:
-  metadata.gz: 2eabdfe3403067cd795090593deeb96ba2a7d70ace07e9e7540d598df234134bf5969143fcdc27695a09bf65692c24e6fb78db3f59a91b3ce8d741f43382b5c1
-  data.tar.gz: eb0e3cd227b22842584c686b9c93af7ca36434d2754132f58544fcc72b69b406630639abf2a021f2c2c160ecd3c6451d4c842517b806299198aaa5bf48a73a13
+  metadata.gz: da62f2782de29b146aa36909f9ddf40d4135379535a5a885abb6a1e50a981218d066d9f0dc444f8e7a678f1cac85375ba3385ace6bbc48be5ad37ef5c9fc29f5
+  data.tar.gz: c05bc29469b5b61629ef4e0575efae12f99a665fdba8df9f23d4f8106de83aa52b3b2fc124c741de525ab9e234c4b599dded80597ebe9824ddd7f2786dd606c6

data/README.md

@@ -216,12 +216,17 @@ RBridge.create_extptr( ffi_ptr )
 
 * Create R function call
 
-create_function_call creates R's internal S expresion structure for function call.
+create_ns_function_call, create_env_function_call and create_function_call create R's internal S expresion structures for function calls. create_ns_function_call can specify (package) namespace. create_env_function_call can specify environment name.
+
+Arguments are passed as Ruby's Hash like objects, Hash or assocation Array, and their each element's value needs to be R's object. For these R objects You can assign not only R vectors but also other function calls.
+
+Assocation Arrays are useful when you have more than one elements with the same key name, which Hash does not allow. This happens when you do not specify parameter name and you use empty Strings, "", as parameter names.
 
-Arguments are passed to the second argument as Ruby Hash, and each Hash's value needs to point to R's object. You usually pass R vectors, but you can also pass another function call as an argument.
 
 ```
-RBridge.create_function_call( fname,  hash )
+RBridge.create_ns_function_call( ns, fname, hash_like )
+RBridge.create_env_function_call( env, fname, hash_like )
+RBridge.create_function_call( fname,  hash_like )
 
 (e.g.)
 # pass vector to argument
@@ -231,6 +236,25 @@ RBridge.exec_function_no_return(hellowrold)
 # pass another function call to argument
 getwd = RBridge.create_function_call( "print", { "x" => RBridge.create_function_call( "getwd", {} ) } )
 RBridge.exec_function_no_return(getwd)
+
+# call sqrt function in base package.
+ivec = RBridge.create_intvec([1,2,3])
+calc = RBridge.create_ns_function_call( "base","sqrt", {"x" => ivec} )
+RBridge.exec_function_no_return( RBridge.create_function_call( "print", {"" => calc} )) # execute & print out
+
+# Call function in environment
+#
+# (e.g.) source the following newenv.R and call the newenv$hello function.
+# # newenv.R
+# newenv = new.env()
+# newenv$hello = function(){ print("Hello!") }
+#
+RBridge.exec_function_no_return( RBridge.create_function_call("source", { "" => RBridge.create_strvec(["newenv.R"]) }))
+RBridge.exec_function_no_return( RBridge.create_env_function_call("newenv", "hello", { } ))
+
+# pass association Array to argument
+add = RBridge.create_function_call( "+", [["" , RBridge.create_intvec( [1,2,3] )],["", RBridge.create_intvec( [10,20,30] ) ]] )
+RBridge.exec_function( RBridge.create_function_call("print", [["" , add ]]))
 ```
 
 The followings are utility functions. assign() and library() are frequently used in R, and easy ways to create them are provided.
@@ -356,7 +380,7 @@ RBridge.end_embedded_r()
 
 ## Additional Features
 
-* LazyFunc + RParamManager (+ RResultManager): In contrast to create_function_call(), create_lazy_funcion(), which create LazyFunc object, does not need to take existent R objects. It can take RParamName, RResultName and so on, which are not associated with R objects until the function is evaluated.
+* LazyFunc + RParamManager (+ RResultManager): In contrast to create_function_call(), create_lazy_function(), which creates LazyFunc object, does not need to take existent R objects. It can take RParamName, RResultName and so on, which are not associated with R objects until the function is evaluated. create_ns_lazy_function(), create_env_lazy_function() are lazy evaluation version of create_ns_function_call() and create_env_function_call(), which respectively allows specifying namespaces and environments.
 
 These features are being developed for StatSailr, and the API is not stable. They can be accessed but they are not recommended for general usage.
 

data/ext/r_bridge/r_embed.c

@@ -2,25 +2,55 @@
 #include <Rembedded.h>
 #include <Rdefines.h>
 
+#include <stdbool.h>
+
+#include <stdint.h>
+#define CSTACK_DEFNS
+#include <Rinterface.h>
+
 #include "win_compat.h"
 
+#ifdef __FreeBSD__
+#include <ieeefp.h>
+fp_rnd_t fpmask_preset;
+#endif
+
 EXPORT void
-r_embedded_init()
+r_embedded_init( bool unlimited_stack_size )
 {
-    size_t localArgc = 2;
-    char localArgs[][50] = {"R", "--silent"};
+
+    #ifdef __FreeBSD__
+        fpmask_preset = fpsetmask(0);
+    #endif
+
+    size_t localArgc = 3;
+    char localArgs[][50] = {"R", "--silent", "--vanilla"};
 
     char *args[ localArgc ];
     for (size_t i = 0; i < localArgc; ++i){
         args[i] = localArgs[i];
     }
 
-    Rf_initEmbeddedR( localArgc , args );
+    // Rf_initEmbeddedR raises C stack usage limit error on multithreading environment.
+    // Rf_initEmbeddedR( localArgc , args ); is replaced with the following code.
+
+    if( unlimited_stack_size == false ){  // default stack size
+      Rf_initialize_R( localArgc , args );
+      setup_Rmainloop();
+    }else{
+      Rf_initialize_R( localArgc , args );
+      R_CStackLimit = (uintptr_t) -1 ;  // Set -1 for unlimited C stack size.
+      setup_Rmainloop();
+    }
 }
 
 EXPORT void
 r_embedded_end()
 {
     Rf_endEmbeddedR(0);
+
+    #ifdef __FreeBSD__
+        fpsetmask(fpmask_preset);
+    #endif
 }
 

data/ext/r_bridge/r_lang.c

@@ -4,6 +4,22 @@
 
 #include "win_compat.h"
 
+EXPORT SEXP
+r_lang_create_ns_fcall( const char* ns, const char* fname, SEXP args)
+{
+    SEXP func;
+    PROTECT( func = LCONS( LCONS( Rf_install("::"), LCONS( Rf_install(ns), LCONS( Rf_install(fname), R_NilValue))) , args ));
+    return func;
+}
+
+EXPORT SEXP
+r_lang_create_env_fcall( const char* env, const char* fname, SEXP args)
+{
+    SEXP func;
+    PROTECT( func = LCONS( LCONS( Rf_install("$"), LCONS( Rf_install(env), LCONS( Rf_install(fname), R_NilValue))) , args ));
+    return func;
+}
+
 EXPORT SEXP
 r_lang_create_fcall( const char* fname, SEXP args)
 {
@@ -12,7 +28,6 @@ r_lang_create_fcall( const char* fname, SEXP args)
     return func;
 }
 
-
 EXPORT SEXP
 r_lang_cons( SEXP car, SEXP cdr)
 {

data/lib/r_bridge/r_bridge_ffi.rb

@@ -7,7 +7,7 @@ module RBridge
   lib_name = "librbridge" + "." + RbConfig::CONFIG['DLEXT']
   ffi_lib File.expand_path( lib_name, __dir__ )
 
-  attach_function :r_embedded_init, [], :void
+  attach_function :r_embedded_init, [:bool], :void
   attach_function :r_embedded_end, [], :void
 
   attach_function :r_vec_create_str, [:int], :pointer
@@ -24,6 +24,8 @@ module RBridge
   attach_function :r_list_to_dataframe, [:pointer ], :pointer
   attach_function :r_dataframe_set_rownames, [:pointer, :pointer], :void
 
+  attach_function :r_lang_create_ns_fcall, [:string, :string, :pointer], :pointer
+  attach_function :r_lang_create_env_fcall, [:string, :string, :pointer], :pointer
   attach_function :r_lang_create_fcall, [:string, :pointer], :pointer
   attach_function :r_lang_cons, [:pointer, :pointer], :pointer
   attach_function :r_lang_cons_gen, [:pointer], :pointer
@@ -47,8 +49,11 @@ module RBridge
 
   # From here, Ruby interface
 
-  def self.init_embedded_r()
-    r_embedded_init()
+  def self.init_embedded_r( unlimited_cstack: false )
+    if(unlimited_cstack.class != TrueClass && unlimited_cstack.class != FalseClass)
+      raise "init_embedded_r() can take true or false for unlimited C stack size. true: unlimited, false: default." 
+    end
+    r_embedded_init( unlimited_cstack )
   end
 
   def self.end_embedded_r()
@@ -256,6 +261,8 @@ module RBridge
       else
         r_obj = value.to_r_symbol
       end
+    when value.class == NilClass
+      r_obj = RBridge.r_nil
     end
     return r_obj
   end
@@ -272,6 +279,10 @@ module RBridge
     return new_lcons
   end
 
+  def self.r_nil()
+    return r_lang_nil()
+  end
+
   def self.is_r_nil?( obj )
     result = r_is_nil( obj )
     if(result == 1)
@@ -294,21 +305,44 @@ module RBridge
     return extptr
   end
 
-  def self.create_function_call( fname,  hash )
-    raise "create_function_call should take String for function name" if(fname.class != String) 
-    raise "create_function_call should take Hash for function arguments" if(hash.class != Hash)
-    if(hash.size == 0)
+  def self.array_depth (ary)
+    return 0 unless ary.is_a?(Array)
+    return 1 + ary.map(){|elem| array_depth(elem) }.max()
+  end
+
+  def self.assoc_array?(ary)
+    if ary.map(){|elem| elem.size }.uniq == [2]
+      true
+    else
+      false
+    end
+  end
+
+  def self.hash_to_lcons_args( hash_like )
+    if hash_like.class == Hash
+      # hash
+    elsif hash_like.class == Array
+      if array_depth(hash_like) == 2 && assoc_array?(hash_like)
+        # association array
+      else
+        raise "hash_to_lcons_args should take Hash argument (or Association Array argument)"
+      end
+    else
+      raise "hash_to_lcons_args should take Hash argument (or Association Array argument)"
+    end
+
+    if(hash_like.size == 0)
       lcons_args = r_lang_nil()
-    elsif(hash.size == 1)
-      tag = hash.first[0]
-      val = hash.first[1]
+    elsif(hash_like.size == 1)
+      tag = hash_like.first[0]
+      val = hash_like.first[1]
       lcons_args = lcons_gen( val )
       if( tag != "" )
         set_tag_to_lcons( lcons_args, tag )
       end
     else
       idx = 0
-      hash.reverse_each(){|arg|
+      hash_like.reverse_each(){|arg|
         tag = arg[0]
         val = arg[1]
         if(idx == 0 )
@@ -322,6 +356,36 @@ module RBridge
         idx = idx + 1
       }
     end
+    return lcons_args
+  end
+
+  def self.create_ns_function_call( ns, fname, hash_like )
+    raise "create_ns_function_call should take String for namespace" if(ns.class != String) 
+    raise "create_ns_function_call should take String for function name" if(fname.class != String) 
+    raise "create_ns_function_call should take Hash like structure for function arguments" if(hash_like.class != Hash && hash_like.class != Array)
+    lcons_args = hash_to_lcons_args( hash_like )
+
+    new_function_call = r_lang_create_ns_fcall(ns, fname, lcons_args)
+    ptr_manager_add_ptr_to_current( new_function_call )
+    return new_function_call
+  end
+
+  def self.create_env_function_call( env, fname, hash_like )
+    raise "create_env_function_call should take String for env" if(env.class != String) 
+    raise "create_env_function_call should take String for function name" if(fname.class != String) 
+    raise "create_env_function_call should take Hash like structure for function arguments" if(hash_like.class != Hash && hash_like.class != Array)
+    lcons_args = hash_to_lcons_args( hash_like )
+
+    new_function_call = r_lang_create_env_fcall(env, fname, lcons_args)
+    ptr_manager_add_ptr_to_current( new_function_call )
+    return new_function_call
+  end
+
+  def self.create_function_call( fname,  hash_like )
+    raise "create_function_call should take String for function name" if(fname.class != String) 
+    raise "create_function_call should take Hash like structure for function arguments" if(hash_like.class != Hash && hash_like.class != Array)
+    lcons_args = hash_to_lcons_args( hash_like )
+
     new_function_call = r_lang_create_fcall(fname, lcons_args)
     ptr_manager_add_ptr_to_current( new_function_call )
     return new_function_call

data/lib/r_bridge/r_bridge_lazyfunc_ext.rb

@@ -1,25 +1,48 @@
 require "r_bridge/r_bridge_ffi"
 
 module RBridge
-  def self.create_lazy_function( fname, hash , param_manager)
+  def self.create_ns_lazy_function( ns, fname, hash_like , param_manager)
+    raise "create_ns_lazy_function should take String for namespace" if(ns.class != String) 
+    raise "create_ns_lazy_function should take String for function name" if(fname.class != String) 
+    raise "create_ns_lazy_function should take Hash like structure for function arguments" if(hash_like.class != Hash && hash_like.class != Array)
+    return LazyFunc.new( ns, nil, fname, hash_like, param_manager)
+  end
+
+  def self.create_env_lazy_function( env, fname, hash_like , param_manager)
+    raise "create_env_lazy_function should take String for environment" if(env.class != String) 
+    raise "create_env_lazy_function should take String for function name" if(fname.class != String) 
+    raise "create_env_lazy_function should take Hash like structure for function arguments" if(hash_like.class != Hash && hash_like.class != Array)
+    return LazyFunc.new( nil, env, fname, hash_like, param_manager)
+  end
+
+  def self.create_lazy_function( fname, hash_like , param_manager)
     raise "create_lazy_function should take String for function name" if(fname.class != String) 
-    raise "create_lazy_function should take Hash for function arguments" if(hash.class != Hash)
-    return LazyFunc.new( fname, hash , param_manager)
+    raise "create_lazy_function should take Hash like structure for function arguments" if(hash_like.class != Hash && hash_like.class != Array)
+    return LazyFunc.new( nil, nil, fname, hash_like, param_manager)
   end
 
-  def self.create_function_call_from_lazy_function( fname, fargs, param_manager, result_manager)
-    farg_keys = fargs.keys
+  def self.create_function_call_from_lazy_function_attrs( ns, env, fname, fargs, param_manager, result_manager)
+
+    new_arg_assoc_array = []
+    fargs.each(){|key, val|
+
+      if val.is_a? RResultPrevious
+        r_previous = result_manager.get_previous() # if r_nil (i.e. 1st instruction or no previous result-store instructions) we need to use default one.
+        if ! RBridge::is_r_nil?(r_previous)  # When previous result exists
+          new_arg_assoc_array << [key, r_previous]
+          next
+        else  # When previous result does not exist
+          val = val.default
+        end
+      end
 
-    new_arg_hash = {}
-    farg_keys.each(){|key|
-      val = fargs[key]
       case val
       when LazyFunc then
-        new_arg_hash[key] = create_function_call_from_lazy_function( val.fname, val.args , param_manager, result_manager )
+        new_arg_assoc_array << [key, create_function_call_from_lazy_function_attrs( val.ns, val.env, val.fname, val.args , param_manager, result_manager )]
       when RResultName , RResultNameArray then 
-        new_arg_hash[key] = result_manager.get_last_for( val )
+        new_arg_assoc_array << [key, result_manager.get_last_for( val )]
       when RParamName then
-        new_arg_hash[key] = param_manager.get_r_object( val )
+        new_arg_assoc_array << [key, param_manager.get_r_object( val )]
       when RNameContainer then
         idx = 0
         while idx < val.elems.size do
@@ -27,51 +50,71 @@ module RBridge
           case elem
           when RResultName, RResultNameArray then 
             result = result_manager.get_last_for( elem )
-            if( ! result.nil? )
-              new_arg_hash[key] = result
+            if( ! RBridge::is_r_nil?(result) )
+              new_arg_assoc_array << [key, result]
               break
             end
           when RParamName then
             result = param_manager.get_r_object( elem )
-            if( ! result.nil? )
-              new_arg_hash[key] = result
+            if( ! RBridge::is_r_nil?(result) )
+              new_arg_assoc_array << [key, result]
               break
             end
           else  # R object
-            new_arg_hash[key] = val
+            new_arg_assoc_array << [key, val]
             break
           end
           idx = idx + 1
         end
         if(idx == val.elems.size ) # Not found
-          new_arg_hash[key] = nil
+          new_arg_assoc_array << [key, RBridge::r_nil()]
         end
+      when RInstPrevious
+        new_arg_assoc_array << [key, result_manager.get_previous_inst_name() ]
       else  # R object
-        new_arg_hash[key] = val
+        new_arg_assoc_array << [key, val]
       end
     }
-    return create_function_call( fname, new_arg_hash )
+    if( ns.nil? )
+      if( env.nil? )
+        return create_function_call( fname, new_arg_assoc_array )
+      else
+        return create_env_function_call( env, fname, new_arg_assoc_array )
+      end
+    else
+      if( env.nil? )
+        return create_ns_function_call( ns, fname, new_arg_assoc_array )
+      else
+        raise "namespace and environment are not allowed to be specified at the same time."
+      end
+    end
   end
 
   def self.exec_lazy_function( lazy_func , result_manager , allow_nil_result: false )
     raise "exec_lazy_function should take LazyFunc object" if(lazy_func.class != LazyFunc) 
     raise "exec_lazy_function should take RResultManager or Nil for 2nd argment: " + result_manager.class.to_s  if(! [RResultManager, NilClass].include?(result_manager.class) )
+    ns = lazy_func.ns
+    env = lazy_func.env
     fname = lazy_func.fname
     arg_hash = lazy_func.args
     param_manager = lazy_func.param_manager
 
-    func = create_function_call_from_lazy_function(fname, arg_hash, param_manager, result_manager)
+    func = create_function_call_from_lazy_function_attrs(ns, env, fname, arg_hash, param_manager, result_manager)
     result = exec_function( func , allow_nil_result: allow_nil_result )
     return result
   end
 
   class LazyFunc
+    attr :ns
+    attr :env
     attr :fname
     attr :args
     attr :param_manager
 
-    def initialize( fname, arg_hash, param_manager)
+    def initialize( ns, env, fname, arg_hash, param_manager)
       raise "LazyFunc requires RParamManager object for param_manager argument " if ! param_manager.is_a?(RParamManager)
+      @ns = ns  # When namespace does not need to be specified, set nil.
+      @env = env  # When environment does not need to be specified, set nil.
       @fname = fname
       @args = arg_hash
       @param_manager = param_manager
@@ -86,6 +129,7 @@ module RBridge
   end
 
   class RParamManager
+    attr :param_hash , true
     def initialize(hash)
       @param_hash = hash
     end
@@ -112,6 +156,22 @@ module RBridge
     end
   end
 
+  class RResultPrevious
+    # RResultPrevious is used for result from the previous instruction.
+    # If the instruction is the 1st one, there are no previous ones. At this time, default one is used.
+    attr :default
+    def initialize(val)
+      if ! ( val.is_a?(RNameContainer) || val.is_a?(RResultName) || val.is_a?(RResultNameArray) || val.is_a?(RParamName) || ::RBridge.is_pointer?( val ) )
+        raise "RResultPrevious.new requires RNameContainer, RResultName, RResultNameArray, RParamName or R object as default"
+      end
+      @default = val
+    end
+  end
+
+  class RInstPrevious
+    # RInstPrevious is used to obtain the previous instruction name.
+  end
+
   class RResultManager
     def initialize
       @results = []
@@ -125,7 +185,7 @@ module RBridge
       @results << [inst_name, r_obj ]
     end
 
-    def get_last_index_for( result_name )
+    def get_last_index_for( result_name ) # From this method, if result name is not found return (Ruby) nil.
         name = result_name.name
 
         idx = @results.size - 1
@@ -143,18 +203,18 @@ module RBridge
         end
     end
 
-    def get_last_for( r_result )  # If corresponding result name is not found, return nil.
+    def get_last_for( r_result )  # If corresponding result name is not found, return r_nil().
       raise "get_last_for method requires RResultName or RResultNameArray for its argument." if ! ( r_result.is_a?(RResultName) || r_result.is_a?(RResultNameArray) )
       if( r_result.is_a? RResultName)
         inst_name = r_result.name
 
         elem_to_match = @results.reverse.find{|elem| elem[0] == inst_name }
         if elem_to_match.nil?
-          return nil
+          return RBridge::r_nil()
         else
           r_obj = elem_to_match[1]
           if RBridge::is_r_nil?( r_obj )
-            return nil
+            return RBridge::r_nil()
           else
             return r_obj
           end
@@ -170,7 +230,7 @@ module RBridge
         }
 
         if( index_array.all?(nil) )
-          return nil
+          return RBridge::r_nil()
         else
           index_array.delete(nil)
           if ! index_array.empty?
@@ -178,13 +238,32 @@ module RBridge
             r_obj = @results[last_idx][1]
             return r_obj
           else
-            return nil
+            return RBridge::r_nil()
           end
         end
       else
         raise "get_last_for() takes unexpected object"
       end
     end
+
+    def get_previous()
+       if @results.size > 0
+        r_obj = @results.last[1]
+        return r_obj
+      else
+        return RBridge::r_nil()
+      end
+    end
+
+    def get_previous_inst_name()
+      if @results.size > 0
+        last_inst_name = @results.last[0]
+        r_obj = RBridge::create_strvec([last_inst_name])
+        return r_obj
+      else
+        return RBridge::r_nil()
+      end
+    end
   end
 
   class RNameContainer

data/lib/r_bridge/version.rb

@@ -1,3 +1,3 @@
 module RBridge
-  VERSION = "0.5.1"
+  VERSION = "0.5.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: r_bridge
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.5
 platform: ruby
 authors:
 - Toshihiro Umehara
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-04 00:00:00.000000000 Z
+date: 2021-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -73,7 +73,7 @@ metadata:
   homepage_uri: https://github.com/niceume/r_bridge
   source_code_uri: https://github.com/niceume/r_bridge
   changelog_uri: https://github.com/niceume/r_bridge
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -88,8 +88,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.31
+signing_key:
 specification_version: 4
 summary: Enables Ruby to construct and evaluate R internal objects
 test_files: []