r_bridge 0.5.0 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbeed05e728b4a713d765b889957fde99c7afa4a8379bbe5220ec39401c62de8
-  data.tar.gz: 1fd7ebe821f80b039fd6ec84311fea02a4feebda0552c62ddb0673fb4999bbd3
+  metadata.gz: b2f3e3fc8242a4204e378f7f86bcc3ca120b163aca161e7b5f7bca12f66eecc3
+  data.tar.gz: 64d9be810cc38ed60bff9204c8dbdf5e1668d295f99d617f7bcfbcf91aea0041
 SHA512:
-  metadata.gz: 22332956afff7dd86e4803b12912f5f349e04d390fb7d16b94f0bbefbd1fb74313d294bf9045c556ba6ee43c27d1e29a39c88c13877ac4a9d9cc60cec7ebf25a
-  data.tar.gz: d9b515e48c8ee6df50b2f1d14d2f75623bac6b1f933e10e00f6ae1626788a7907d9d38093bda13bc8cfdb92ca34e58cd2bc7a8bf8945ad03deae3e7ad7c72ed7
+  metadata.gz: 3af47902e433e3d7be48d472a28d6d84d6cb684f09fa321db31cf8d2ad007af682d8ad401aba3544158fb9853262f224e531a9c0e769c22aa27957b307a4015a
+  data.tar.gz: a43acbb159c37d3ac14ca2580090c810081977d44786812349d901d8ba450173b21ee6ac412a1e9962378fa075030e9b56b52b53e786804969c2fe7406d52257

data/README.md

@@ -41,12 +41,14 @@ Depending on installing via source or binary, necessary settings differ. If you
             + This path should have libR.pc file.
 5. For R to properly work, R_HOME variable is sometimes required. Set it to the root directory that contains R libraries.
     + (e.g.) export R_HOME=/usr/lib64/R
-6. Install 'r_bridge' via gem
+6. Install 'r_bridge' gem
 
 ```
 gem install r_bridge
 ```
 
+
+
 * For Windows
 
 For windows, there is a known issue. Output from R contains unknown characters, which may relate to UTF16 conversion within Windows.
@@ -57,15 +59,13 @@ For windows, there is a known issue. Output from R contains unknown characters,
 2. Make sure that R.exe and R.dll can be seen from your system.
     + For Windows, add path for R.exe (e.g. C:\Program Files\R\R-4.0.2\bin ) to 'Path' system or user variable.
     + Also, create 'RUBY_DLL_PATH' system or user variable, which includes path for R.dll (e.g. C:\Program Files\R\R-4.0.2\bin\x64 ).
-3. Install 'r_bridge' via gem
+3. Install 'r_bridge' gem
 
 ```
 gem install r_bridge
 ```
 
 
-
-
 ## Example
 
 * Example 1
@@ -203,15 +203,30 @@ ary = [ RBridge::SymbolR.new("y"),
 formula = RBridge::create_formula_from_syms( ary )  # y ~ x
 ```
 
+* Create EXTPTRSXP type object
+
+If you need to deal with external pointers in R, you can hold them with EXTPTRSXP type objects.
+
+create_extptr takes FFI::Pointer as its argument, and creates EXTPTRSXP object. Internally R_MakeExternalPtr() C function is used.
+
+```
+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
@@ -221,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.
@@ -346,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/Rakefile

@@ -1,10 +1,44 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require 'rake/clean'
 
+message_for_rake_compiler = "This gem requires native extension compilation. rake-compiler gem should be installed and 'rake compile' before 'rake test'."
+
+begin
+  require "rake/extensiontask"
+rescue LoadError => e
+  puts "ERROR:" + message_for_rake_compiler
+  raise
+end
+raise ("ERROR:" + message_for_rake_compiler) unless defined? Rake::ExtensionTask
+
+# rake compile
+Rake::ExtensionTask.new do |ext|
+  ext.name = "librbridge" # This should be same as shared library name specified in create_makefile of extconf.rb
+  ext.ext_dir = "ext/r_bridge"
+  ext.lib_dir = "lib/r_bridge"
+end
+
+# rake test
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
+# rake example
+task :example do
+  file_list = Dir.glob("example/example*.rb")
+  file_list.each(){|path|
+    puts "###### Running script #{path} #####"
+    ruby path
+    puts ""
+  }
+end
+
+# rake clean
+CLEAN.include(["tmp/", "lib/r_bridge/librbridge.so"])
+
+
 task :default => :test
+task :test => :compile

data/example/example.rb

@@ -0,0 +1,56 @@
+require("r_bridge")
+
+RBridge.init_embedded_r()
+
+fun = RBridge.create_function_call("getwd", {} )
+path = RBridge.exec_function(fun)
+RBridge.exec_function( RBridge.create_function_call( "print", { "x" => path } ))
+
+RBridge.exec_function( RBridge.create_function_call( "print", { "x" => RBridge.create_function_call("getwd", {} ) } ))
+
+RBridge.ptr_manager_open ("mean_function") {
+  i_v = RBridge.create_vec([0,1,2,3,4,5,6,7,8,9,10,50])
+  r_v = RBridge.create_vec( [0.2] )
+  func = RBridge.create_function_call( "mean", {"trim" => r_v  , "x" => i_v })
+  result = RBridge.exec_function(func)
+
+  # print RBridge.confirm_type( result, :REALSXP )
+  func2 = RBridge.create_function_call( "print", { "x" => result } )
+  RBridge.exec_function(func2)
+}
+
+RBridge.ptr_manager_open("cat hello world"){
+  s_v = RBridge.create_vec( ["Hello", "World", "from", "Ruby+R", "\n"] )
+  func3 = RBridge.create_function_call( "cat", { "" => s_v } )
+  RBridge.exec_function_no_return(func3)  # Here exec_function() raises error b/c return value is nil.
+}
+
+RBridge.ptr_manager_open("prepare regression analysis"){
+  ary = [ RBridge::SymbolR.new("y"),
+          RBridge::SymbolR.new("~"),
+          RBridge::SymbolR.new("x")]
+  formula = RBridge::create_formula_from_syms( ary )
+
+  df = RBridge::create_dataframe( { "y" => [12, 13, 14, 18 , 17, 20, 20 ] , "x" => [ 1, 2, 3, 4, 5, 6, 7]} )
+
+  # assign to R variable
+  RBridge::exec_function( RBridge::create_assign_function( "formula" , formula ) )
+  RBridge::exec_function( RBridge::create_assign_function( "df" , df ))
+}
+
+RBridge.ptr_manager_open("run regression analysis. lm(formula, data) "){
+  # obtain from R variable
+  formula =  RBridge::SymbolR.new("formula").to_r_symbol
+  df = RBridge::SymbolR.new("df").to_r_symbol
+
+  func4 = RBridge.create_function_call( "lm", { "formula" => formula , "data" => df } )
+  model = RBridge.exec_function(func4)
+  func5 = RBridge.create_function_call( "summary", { "object" => model })
+  summary = RBridge.exec_function(func5)
+  func6 = RBridge.create_function_call( "print", { "x" => summary })
+  RBridge.exec_function(func6)
+}
+
+RBridge.gc_all()
+RBridge.end_embedded_r()
+

data/example/example_ptr_manager_block.rb

@@ -0,0 +1,23 @@
+require "r_bridge"
+RBridge.init_embedded_r()
+
+RBridge.ptr_manager_open("prepare regression analysis"){
+  ary = [ RBridge::SymbolR.new("y"),
+          RBridge::SymbolR.new("~"),
+          RBridge::SymbolR.new("x")]
+  formula = RBridge::create_formula_from_syms( ary )
+
+  df = RBridge::create_dataframe( { "y" => [12, 13, 14, 18 , 17, 20, 20 ] , "x" => [ 1, 2, 3, 4, 5, 6, 7]} )
+
+  RBridge.ptr_manager_open("a little break"){
+    RBridge::exec_function_no_return(RBridge::create_function_call("print", {"x" => RBridge::create_vec( ["(^^)" , "<" , "Hello"] ) }))
+  }
+
+  # assign to R variable
+  reg = RBridge::exec_function( RBridge::create_function_call( "lm" , {"data" => df , "formula" => formula } ) )
+  summary = RBridge::exec_function( RBridge::create_function_call( "summary" , {"object" => reg } ) )
+  RBridge::exec_function_no_return(RBridge::create_function_call( "print" , {"x" => summary }))
+}
+
+RBridge.gc_all() # In this case, not necesary. ( When there are objects that are not managed by ptr_manager, this is necessary.)
+RBridge.end_embedded_r()

data/example/example_ptr_manager_explicit_use.rb

@@ -0,0 +1,10 @@
+require "r_bridge"
+RBridge.init_embedded_r()
+
+RBridge.ptr_manager_open("pm1")
+new_vec = RBridge.create_vec(["Hello", "World"])
+RBridge.exec_function_no_return( RBridge.create_function_call("print", {"x" => new_vec }))
+RBridge.ptr_manager_close("pm1")
+
+RBridge.gc_all() # In this case, not necesary. ( When there are objects that are not managed by ptr_manager, this is necessary.)
+RBridge.end_embedded_r()

data/example/example_using_lcons.rb

@@ -0,0 +1,14 @@
+require "r_bridge"
+
+RBridge.init_embedded_r()
+
+getwd = RBridge.create_function_call( "print", { "x" => RBridge.create_function_call( "getwd", {} ) } )
+RBridge.exec_function_no_return(getwd)
+
+lcons1 = RBridge.lcons_gen( RBridge.create_vec(["Hello", "World"]) )
+RBridge.set_tag_to_lcons( lcons1, "x")
+lcons2 = RBridge.lcons(RBridge.r_lang_symbol("print") , lcons1)
+RBridge.exec_function_no_return(lcons2)
+
+RBridge.gc_all()
+RBridge.end_embedded_r()

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)
 {
@@ -43,6 +58,14 @@ r_lang_symbol( const char* symbol_name)
     return r_symbol;
 }
 
+EXPORT SEXP
+r_lang_create_extptr( void* ptr )
+{
+    SEXP extptr;
+    PROTECT( extptr = R_MakeExternalPtr( ptr, R_NilValue, R_NilValue ));
+    return extptr;
+}
+
 EXPORT SEXP
 r_lang_nil()
 {

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,12 +24,16 @@ 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
   attach_function :r_lang_set_tag, [:pointer, :string], :void
   attach_function :r_lang_symbol, [:string], :pointer
 
+  attach_function :r_lang_create_extptr, [:pointer], :pointer
+
   attach_function :r_eval, [:pointer], :pointer
   attach_function :r_eval_no_return, [:pointer], :pointer
 
@@ -45,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()
@@ -185,7 +192,6 @@ module RBridge
       when FalseClass
         1
       else
-        nil
         raise " The current elemnt is not supported to convert to R vector : " + elem
       end
     }
@@ -208,6 +214,7 @@ module RBridge
         when 1
           raise "All the elements shold be true/false. Current value: " + ary[idx]
         end
+        converted
       else
         ary[idx]
       end
@@ -270,6 +277,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)
@@ -283,21 +294,53 @@ module RBridge
     r_lang_set_tag( lcons, tag_name )
   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.create_extptr( ffi_pointer )
+    raise "create_extptr should take a FFI::Pointer argument" if(ffi_pointer.class != FFI::Pointer)
+
+    extptr = r_lang_create_extptr(ffi_pointer)
+
+    ptr_manager_add_ptr_to_current( extptr )
+    return extptr
+  end
+
+  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 )
@@ -311,6 +354,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,69 @@ 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
       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 +127,7 @@ module RBridge
   end
 
   class RParamManager
+    attr :param_hash , true
     def initialize(hash)
       @param_hash = hash
     end
@@ -112,6 +154,18 @@ 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 RResultManager
     def initialize
       @results = []
@@ -125,7 +179,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 +197,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 +224,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 +232,22 @@ 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
   end
 
   class RNameContainer

data/lib/r_bridge/version.rb

@@ -1,3 +1,3 @@
 module RBridge
-  VERSION = "0.5.0"
+  VERSION = "0.5.4"
 end

data/r_bridge.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Toshihiro Umehara"]
   spec.email         = ["toshi@niceume.com"]
 
-  spec.summary       = %q{Enables Ruby to access and construct R internal objects}
-  spec.description   = %q{R (language) provides C interface. This package utilize the interface and allow Ruby to manipulate and evaluate R's internal S expressions }
+  spec.summary       = %q{Enables Ruby to construct and evaluate R internal objects}
+  spec.description   = %q{R (language) provides C interface. This package utilize the interface and allow Ruby to construct and evaluate R's internal S expressions }
   spec.homepage      = "https://github.com/niceume/r_bridge"
   spec.license       = "GPL-3.0"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: r_bridge
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.4
 platform: ruby
 authors:
 - Toshihiro Umehara
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-28 00:00:00.000000000 Z
+date: 2021-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -31,7 +31,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.13.0
 description: 'R (language) provides C interface. This package utilize the interface
-  and allow Ruby to manipulate and evaluate R''s internal S expressions '
+  and allow Ruby to construct and evaluate R''s internal S expressions '
 email:
 - toshi@niceume.com
 executables: []
@@ -47,6 +47,10 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- example/example.rb
+- example/example_ptr_manager_block.rb
+- example/example_ptr_manager_explicit_use.rb
+- example/example_using_lcons.rb
 - ext/r_bridge/extconf.rb
 - ext/r_bridge/r_bridge.c
 - ext/r_bridge/r_embed.c
@@ -84,8 +88,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
-summary: Enables Ruby to access and construct R internal objects
+summary: Enables Ruby to construct and evaluate R internal objects
 test_files: []