jl4rb 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2e556eacfd629abcbddd8756e0ef040beac465a
+  data.tar.gz: 3acd1b2d43241368d81c4a06ae5f9501b379b887
+SHA512:
+  metadata.gz: 99e1ab7677c957848d361191557d928b21cbdc46b011cf9ee70248d4a490f9814f1867f2b157a4c60038cbd81e61b0b504cc817a2751a12629639ac69186bc4c
+  data.tar.gz: a7f1070f72ec507cf31cf0e0216af0dc5b2cea8c3058025ef4f7f8597cfac4d045f34c22acc33ee73e100a9dfbab1724886edb2d7a1a7f2cad615ba25c808de4

data/Rakefile

@@ -0,0 +1,113 @@
+require 'rubygems'
+require 'rake'
+require 'rubygems/package_task'
+
+PKG_NAME='jl4rb'
+PKG_VERSION='0.0.1'
+PKG_FILES=FileList[
+    'Rakefile','jl4rb.gemspec',
+    'ext/jl4rb/*.c',
+    'ext/jl4rb/extconf.rb',
+    'ext/jl4rb/*.inc',
+    'ext/jl4rb/*.h',
+    'ext/jl4rb/MANIFEST',
+    'lib/**/*.rb', 
+    'test/**/*.rb'
+]
+
+spec = Gem::Specification.new do |s|
+    s.platform = Gem::Platform::RUBY
+    s.summary = "Julia for ruby"
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.requirements << 'none'
+    s.require_paths = ["lib","ext/jl4rb"]
+    s.files = PKG_FILES.to_a
+    s.extensions = ["ext/jl4rb/extconf.rb"]
+    s.licenses = ['MIT', 'GPL-2']
+    s.description = <<-EOF
+  R is embedded in ruby with some communication support .
+  EOF
+    s.author = "CQLS"
+    s.email= "rdrouilh@gmail.com"
+    s.homepage = "http://cqls.upmf-grenoble.fr"
+    s.rubyforge_project = nil
+end
+
+## this allows to produce some parameter for task like  Gem::PackageTask (without additional argument!)
+opt={};ARGV.select{|e| e=~/\=/ }.each{|e| tmp= e.split("=");opt[tmp[0]]=tmp[1]}
+
+## rake ... pkgdir=<path to provide> to update PKGDIR
+PKGDIR=opt["pkgdir"] || ENV["RUBYGEMS_PKGDIR"]  || "pkg"
+## OLD: gem task!!!
+# desc "Create #{PKG_NAME+'-'+PKG_VERSION+'.gem'}" 
+# Gem::PackageTask.new(spec) do |pkg|
+#   pkg.package_dir=PKGDIR
+#   pkg.need_zip = false
+#   pkg.need_tar = false
+# end
+
+# it is less verbose than the previous one
+desc "Create #{PKG_NAME+'-'+PKG_VERSION+'.gem'}" 
+task :package do |t|
+  #Gem::Builder.new(spec_client).build
+  unless File.directory? PKGDIR
+    require 'fileutils'
+    FileUtils.mkdir_p PKGDIR
+  end
+  Gem::Package.build(spec)
+  `mv #{PKG_NAME+'-'+PKG_VERSION+'.gem'} #{PKGDIR}`
+end
+
+## clean task
+desc "Remove #{File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION+'.gem')}"
+task :clean do |t|
+  rm File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION+'.gem') if File.exists? File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION+'.gem')
+  rm_rf File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION) if File.exists? File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION)
+end
+
+
+## install task with doc
+desc "Install #{File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION+'.gem')}"
+task :install_with_doc do |t|
+  `gem install #{File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION+'.gem')} --local`
+end
+
+## quick install task
+desc "Quick install #{File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION+'.gem')}"
+task :install do |t|
+  `gem install #{File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION+'.gem')} --local --no-rdoc --no-ri`
+  rm_rf File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION) if File.exists? File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION)
+end
+
+desc "Docker install #{File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION+'.gem')}"
+task :docker => :package do |t|
+  `gem install #{File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION+'.gem')} --local --no-rdoc --no-ri`
+  rm_rf File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION) if File.exists? File.join(PKGDIR,PKG_NAME+'-'+PKG_VERSION)
+end
+
+
+## binary task (mainly for Windows binary)
+spec_bin=Gem::Specification.new do |s|
+    s.platform = Gem::Platform::CURRENT
+    s.summary = "Julia for ruby"
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.requirements << 'none'
+    s.require_paths = ["lib"]
+    s.files = Dir['lib/**/*.rb'] + Dir['lib/*.so']
+    s.required_ruby_version = '>= 1.8.0'
+    s.description = <<-EOF
+  R is embedded in ruby with some communication support .
+  EOF
+    s.author = "CQLS"
+    s.email= "rdrouilh@gmail.com"
+    s.homepage = "http://cqls.upmf-grenoble.fr"
+    s.rubyforge_project = nil
+    s.has_rdoc = false
+end
+
+task :gem_bin do |t|
+  `cp ext/jl4rb/*.so lib` 
+  Gem::Builder.new(spec_bin).build
+end

data/ext/jl4rb/extconf.rb

@@ -0,0 +1,44 @@
+require "mkmf"
+require 'fileutils' #if RUBY_VERSION < "1.9"
+
+
+$prefix_include,$prefix_lib=[],[]
+if RUBY_PLATFORM =~ /linux/ and File.exists? "/usr/include/"+RUBY_PLATFORM+"/julia"
+    $prefix_include << "/usr/include/"+RUBY_PLATFORM+"/julia"
+    $prefix_lib << "/usr/lib/"+RUBY_PLATFORM+"/julia"
+else
+    #$prefix=ENV["JLAPI_HOME"] || File.join(ENV["HOME"],".jlapi/julia") || ENV["JULIA_HOME"]
+    $prefix=ENV["JULIA_DIR"]
+    #p  $prefix
+    [$prefix+"/include/julia",$prefix+"/usr/include",$prefix+"/src",$prefix+"/src/support"].each do |incl| 
+    	$prefix_include << incl if File.exists? incl
+    end
+
+    ([$prefix+"/lib/julia",$prefix+"/usr/lib"]+(RUBY_PLATFORM=~/(?:mingw|msys)/ ? [$prefix+"/bin"] : [])).each do |lib|
+    	$prefix_lib << lib if File.exists? lib
+    end
+end
+
+def jl4rb_makefile(incs,libs) 
+    #$CFLAGS = "-I"+inc+" -I."
+    # $CFLAGS = (enable_config("julia-release") ? "-DWITH_JULIA_RELEASE " : "")+ "-I"+inc+" -I."
+    # $LDFLAGS = " -Wl,-rpath,"+lib+" -L"+lib if lib
+    # $libs = (enable_config("julia-release") ? " -ljulia-release" : " -ljulia-api" )
+ 
+ 	$CFLAGS =   incs.map{|inc| "-I"+inc}.join(" ")+" -I."
+    $LDFLAGS = " "+libs.map{|lib| "-Wl,-rpath,"+lib+" -L"+lib}.join(" ") if libs
+    $libs =  " -ljulia" 
+ 
+
+    header = nil
+
+    rb4r_name="jl4rb"
+    $objs = [rb4r_name+".o"]
+
+    dir_config("R4rb")
+    create_makefile(rb4r_name)
+end
+
+jl4rb_makefile($prefix_include,$prefix_lib)
+
+ 

data/ext/jl4rb/jl4rb.c

@@ -0,0 +1,558 @@
+/**********************************************************************
+
+  jl4rb.c
+
+**********************************************************************/
+
+#include "julia.h"
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+//#define WITH_JULIA_RELEASE
+
+//#ifdef WITH_JULIA_RELEASE
+//#else
+//#include "julia-api.h"
+//#endif
+
+//-| next macros already exist in ruby and are undefined here
+//#undef T_FLOAT
+#undef NORETURN
+#include "ruby.h"
+
+#define length(a) jl_array_size(a,0)
+
+/************* INIT *********************/
+
+
+VALUE Julia_init(VALUE obj, VALUE args)
+{
+  char **argv,*julia_home_dir;
+  int i,argc;
+  VALUE tmp;
+
+  argc=RARRAY_LEN(args) + 1;
+  tmp=rb_ary_entry(args,0);
+  julia_home_dir=StringValuePtr(tmp);
+  //printf("First initialization with julia_home_dir=%s\n",julia_home_dir);
+// printf("copy stacks ");
+// #ifdef COPY_STACKS
+//   printf("defined \n");
+// #else
+//   printf("undefined \n");
+// #endif
+// printf("JL_SET_STACK_BASE ");
+// #ifdef JL_SET_STACK_BASE
+//   printf("defined \n");
+// #else
+//   printf("undefined \n");
+// #endif
+//#ifdef WITH_JULIA_RELEASE
+  if(strcmp(julia_home_dir,"")==0) {
+    jl_init(NULL);
+    //JL_SET_STACK_BASE;
+  } else {
+    jl_init(julia_home_dir);
+    //JL_SET_STACK_BASE;
+  }
+//#else
+//  jlapi_init(julia_home_dir,mode);
+//#endif
+
+  return Qtrue;
+}
+
+//Maybe try to use cpp stuff to get the output inside julia system (ccall,cgen and cgutils)
+//-| TODO: after adding in the jlapi.c jl_is_<C_type> functions replace the strcmp!
+VALUE jl_value_to_VALUE(jl_value_t *res) {
+  size_t i=0,k,nd,d;
+  VALUE resRb;
+  jl_value_t *tmp;
+  jl_function_t *call;
+
+  if(res!=NULL) { //=> get a result
+    //printf("typeof=%s\n",jl_typeof_str(res));
+    if(strcmp(jl_typeof_str(res),"Int64")==0 || strcmp(jl_typeof_str(res),"Int32")==0)
+    //if(jl_is_long(res)) //does not work because of DLLEXPORT
+    {
+      //printf("elt=%d\n",jl_unbox_long(res));
+      return INT2FIX(jl_unbox_long(res));
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"Float64")==0)
+    //if(jl_is_float64(res))
+    {
+      return rb_float_new(jl_unbox_float64(res));
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"Float32")==0)
+    //if(jl_is_float64(res))
+    {
+      return rb_float_new(jl_unbox_float32(res));
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"Bool")==0)
+    //if(jl_is_bool(res))
+    {
+      return (jl_unbox_bool(res) ? Qtrue : Qfalse);
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"DataType")==0)
+    {
+      return rb_str_new2(jl_typename_str(res));
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"Nothing")==0)
+    {
+      return Qnil;
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"Complex")==0)
+    //if(jl_is_bool(res))
+    {
+      resRb = rb_eval_string("require('complex');Complex.new(0,0)");
+      rb_iv_set(resRb,"@real",jl_value_to_VALUE(jl_get_field(res, "re")));
+      rb_iv_set(resRb,"@image",jl_value_to_VALUE(jl_get_field(res, "im")));
+      return resRb;
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"Regex")==0)
+    //if(jl_is_bool(res))
+    {
+      // call=(jl_function_t*)jl_get_global(jl_base_module, jl_symbol("show"));
+      // printf("ici\n");
+      // if (call) tmp=jl_call1(call,res);
+      // else printf("call failed!\n");
+      // printf("ici\n");
+      resRb = jl_value_to_VALUE(jl_get_field(res, "pattern"));
+      return resRb;
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"ASCIIString")==0 || strcmp(jl_typeof_str(res),"UTF8String")==0)
+    {
+      //printf("value=%s\n",jl_bytestring_ptr(res));
+      return rb_str_new2(jl_bytestring_ptr(res));
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"Array")==0 )
+    //if(jl_is_array(res))
+    {
+      nd = jl_array_rank(res);
+      //printf("array_ndims=%d\n",(int)nd);
+      if(nd==1) {//Vector
+        d = jl_array_size(res, 0);
+        //printf("array_dim[1]=%d\n",(int)d);
+        resRb = rb_ary_new2(d);
+        for(i=0;i<d;i++) {
+          rb_ary_store(resRb,i,jl_value_to_VALUE(jl_arrayref((jl_array_t *)res,i)));
+        }
+        return resRb;
+      }
+      //TODO: multidim array ruby equivalent???? Is it necessary
+
+    }
+    else
+    if(strcmp(jl_typeof_str(res),"Tuple")==0 )
+    //if(jl_is_array(res))
+    {
+      d=jl_tuple_len(res);
+      resRb = rb_ary_new2(d);
+      for(i=0;i<d;i++) {
+        rb_ary_store(resRb,i,jl_value_to_VALUE(jl_tupleref(res,i)));
+      }
+      return resRb;
+    }
+    //printf("unconverted!!!");
+    resRb=rb_str_new2("__unconverted(");
+    rb_str_cat2(resRb, jl_typeof_str(res));
+    rb_str_cat2(resRb, ")__\n");
+    //printf("%s\n",jl_bytestring_ptr(jl_eval_string("\"$(ans)\"")));
+    // jl_function_t *call=(jl_function_t*)jl_get_global(jl_base_module, jl_symbol("show"));
+    // if (call) jl_call1(call,res);
+    // else printf("call failed!\n");
+
+    return resRb;
+  }
+  //=> No result (command incomplete or syntax error)
+//#ifndef WITH_JULIA_RELEASE
+//  jlapi_print_stderr(); //If this happens but this is really not sure!
+//#endif
+  //printf("incomplete!!!");
+  resRb=rb_str_new2("__incomplete");
+  if(jl_exception_occurred()!=NULL) {
+    rb_str_cat2(resRb, "(");
+      rb_str_cat2(resRb,jl_typeof_str(jl_exception_occurred()));
+    jl_value_t* err=jl_get_field(jl_exception_occurred(),"msg");
+    if(err!=NULL) printf("%s: %s\n",jl_typeof_str(jl_exception_occurred()),jl_bytestring_ptr(err));
+    jl_exception_clear();
+    rb_str_cat2(resRb, ")");
+  }
+  rb_str_cat2(resRb, "__");
+  return resRb;
+}
+
+/***************** EVAL **********************/
+
+VALUE Julia_eval(VALUE obj, VALUE cmd, VALUE print_stdout)
+{
+  char *cmdString;
+  jl_value_t *res;
+  VALUE resRb;
+
+  cmdString=StringValuePtr(cmd);
+  //printf("cmd=%s\n",cmdString);
+//#ifndef WITH_JULIA_RELEASE
+  //This flush redirected stdout before printing
+  //if(print_stdout!=Qnil) jlapi_get_stdout();
+//#endif
+  //jl_gc_disable();
+  res=jl_eval_string(cmdString);
+  //printf("cmd=%s\n",cmdString);
+  if (jl_exception_occurred()) {
+            jl_show(jl_stderr_obj(), jl_exception_occurred());
+            jl_printf(jl_stderr_stream(), "\n");
+            resRb=Qnil;
+  } else {
+    //JL_GC_PUSH1(&res);
+    //printf("cmd=%s\n",cmdString);
+  //jl_set_global(jl_base_module, jl_symbol("ans"),res);
+//#ifndef WITH_JULIA_RELEASE
+//  if(print_stdout!=Qnil) jlapi_print_stdout();
+//#endif
+  resRb=jl_value_to_VALUE(res);
+  //JL_GC_POP();
+  }
+  //jl_gc_enable();
+  return resRb;
+}
+
+VALUE Julia_exec(VALUE obj, VALUE cmd, VALUE get_stdout)
+{
+  char *cmdString,*outString;
+  jl_value_t *res;
+  VALUE out;
+
+  cmdString=StringValuePtr(cmd);
+  res=jl_eval_string(cmdString);
+  jl_set_global(jl_base_module, jl_symbol("ans"),res);
+  //if(get_stdout!=Qnil) {
+  //  outString=jlapi_get_stdout();
+  //  jl_set_global(jl_base_module, jl_symbol("rbout"),jl_cstr_to_string(outString));
+  //  return  rb_str_new2(outString);
+  //} else
+  return Qnil;
+}
+
+
+/// Util
+
+int util_isVector(jl_value_t *ans)
+{
+  return (strcmp(jl_typeof_str(ans),"Array")==0) && (jl_array_rank(ans)==1);
+}
+
+int util_isVariable(VALUE self)
+{
+  VALUE tmp;
+  tmp=rb_iv_get(self,"@type");
+  return strcmp(StringValuePtr(tmp),"var")==0;
+}
+
+jl_value_t *util_getVar(VALUE self)
+{
+  jl_value_t *ans;
+  char *name;
+  VALUE tmp;
+
+  tmp=rb_iv_get(self,"@name");
+  name=StringValuePtr(tmp);
+  ans=jl_eval_string(name);
+  //printf("name=%s,vector=%d\n",name,util_isVector(ans));
+  if(!util_isVector(ans)) return NULL;
+  return ans;
+}
+
+//with argument!! necessarily an expression and not a variable
+jl_value_t *util_getExpr_with_arg(VALUE self)
+{
+  jl_value_t *ans;
+  VALUE tmp;
+  char *cmd;
+
+  //printf("getVar:%s\n",name);
+  tmp=rb_str_dup(rb_iv_get(self,"@arg"));
+  tmp=rb_str_cat2(rb_str_dup(rb_iv_get(self,"@name")),StringValuePtr(tmp));
+  cmd=StringValuePtr(tmp);
+  ans=jl_eval_string(cmd);
+  if(ans==NULL) return ans;
+  //if(!util_isVector(ans)) return NULL;
+  return ans;
+}
+
+
+VALUE util_jl_value_to_VALUE(jl_value_t *ans)
+{
+  return jl_value_to_VALUE(ans);
+}
+
+
+//-| Transform only a Vector or Atom
+//-| Todo: when not a vector, avoid transform to vector first.
+jl_value_t* util_VALUE_to_jl_value(VALUE arr)
+{
+  jl_value_t *ans,*elt;
+  VALUE res,class,tmp;
+  int i,n=0,vect=1;
+
+  if(!rb_obj_is_kind_of(arr,rb_cArray)) {
+    n=1;
+    res = rb_ary_new2(1);
+    rb_ary_push(res,arr);
+    arr=res;
+    vect=0;
+  } else {
+    n=RARRAY_LEN(arr);
+  }
+
+  class=rb_class_of(rb_ary_entry(arr,0));
+  ans=jl_alloc_cell_1d(n);
+  if(class==rb_cFloat) {
+    //-| This is maybe faster and can be developped in julia-api as jl_vector_float64(n) for example.
+    //ans=jl_alloc_array_1d(jl_float64_type,n);
+    for(i=0;i<n;i++) {
+      elt=jl_box_float64(NUM2DBL(rb_ary_entry(arr,i)));
+      jl_arrayset(ans,elt,i);
+    }
+  } else if(class==rb_cFixnum || class==rb_cBignum) {
+    //ans=jl_alloc_array_1d(jl_long_type,n);
+    for(i=0;i<n;i++) {
+      elt=jl_box_long(NUM2INT(rb_ary_entry(arr,i)));
+      jl_arrayset(ans,elt,i);
+    }
+  } else if(class==rb_cTrueClass || class==rb_cFalseClass) {
+    //ans=jl_alloc_array_1d(jl_bool_type,n);
+    for(i=0;i<n;i++) {
+      elt=jl_box_bool(rb_class_of(rb_ary_entry(arr,i))==rb_cFalseClass ? 0 : 1);
+      jl_arrayset(ans,elt,i);
+    }
+  } else if(class==rb_cString) {
+    //ans=jl_alloc_array_1d(jl_utf8_string_type,n);
+    for(i=0;i<n;i++) {
+      tmp=rb_ary_entry(arr,i);
+      elt=jl_cstr_to_string(StringValuePtr(tmp));
+      jl_arrayset(ans,elt,i);
+    }
+  } else ans=NULL;
+  if(!vect && ans) ans=jl_arrayref(ans,0);
+  return ans;
+}
+
+VALUE JuliaVect_initialize(VALUE self, VALUE name)
+{
+  rb_iv_set(self,"@name",name);
+  rb_iv_set(self,"@type",rb_str_new2("var"));
+  rb_iv_set(self,"@arg",rb_str_new2(""));
+  return self;
+}
+
+VALUE JuliaVect_isValid(VALUE self)
+{
+  jl_value_t* ans;
+  char *name;
+
+  ans = util_getVar(self);
+
+  if(!util_isVector(ans)) {
+    VALUE tmp;
+    tmp=rb_iv_get(self,"@name");
+    name = StringValuePtr(tmp);
+    rb_warn("%s is not a R vector !!!",name);
+    return Qfalse;
+  }
+  return Qtrue;
+}
+
+VALUE JuliaVect_length(VALUE self)
+{
+  jl_value_t* ans;
+  char *name;
+
+  ans = util_getVar(self);
+
+  if(ans==NULL) {
+    //printf("Sortie de length avec nil\n");
+    return Qnil;
+  }
+
+  return INT2NUM(length(ans));
+}
+
+VALUE JuliaVect_get(VALUE self)
+{
+  jl_value_t* ans;
+  VALUE res;
+  char *name;
+  int n,i;
+  VALUE res2;
+
+  ans = util_getVar(self);
+
+  if(ans==NULL) {
+    //printf("Sortie de get avec nil\n");
+    return Qnil;
+  }
+
+  res=util_jl_value_to_VALUE(ans);
+  if(length(ans)==1) res=rb_ary_entry(res,0);
+  return res;
+}
+
+VALUE JuliaVect_get_with_arg(VALUE self)
+{
+  jl_value_t* ans;
+  VALUE res;
+  char *name;
+  int n,i;
+  VALUE res2;
+
+  ans = util_getExpr_with_arg(self);
+
+  if(ans==NULL) {
+    //printf("Sortie de get avec nil\n");
+    return Qnil;
+  }
+  res=util_jl_value_to_VALUE(ans);
+
+//printf("JuliaVect_get_with_arg: length(ans)=%d\n",length(ans));
+ if (length(ans)==1) res=rb_ary_entry(res,0);
+
+  return res;
+}
+
+
+
+// faster than self.to_a[index]
+// VALUE JuliaVect_aref(VALUE self, VALUE index)
+// {
+//   jl_value_t* ans;
+//   VALUE res;
+//   int n,i;
+//   i = FIX2INT(index);
+
+//   ans = util_getVar(self);
+//   n=length(ans);
+//   printf("i=%d and n=%d\n",i,n);
+//   if(i<n) {
+//      res=jl_value_to_VALUE(jl_arrayref((jl_array_t *)ans,i));
+//   } else {
+//     res = Qnil;
+//   }
+//   return res;
+// }
+
+// VALUE JuliaVect_set(VALUE self,VALUE arr)
+// {
+//   jl_value_t* ans;
+//   char *name;
+//   VALUE tmp;
+
+//   ans=util_VALUE_to_jl_value(arr);
+
+//   tmp=rb_iv_get(self,"@name");
+//   name = StringValuePtr(tmp);
+//   jl_set_global(jl_main_module, jl_symbol(name),ans);
+
+//   return self;
+// }
+
+VALUE JuliaVect_set(VALUE self,VALUE arr)
+{
+  VALUE tmp;
+  char *cmd;
+  // defineVar(install(".rubyExport"),util_VALUE2jl_value_t*(arr),R_GlobalEnv);
+  // tmp=rb_iv_get(self,"@arg");
+  // util_eval1string(rb_str_cat2(rb_str_cat2(rb_str_dup(rb_iv_get(self,"@name")),StringValuePtr(tmp)),"<-.rubyExport"));
+  jl_set_global(jl_main_module, jl_symbol("_ruby_export_"),util_VALUE_to_jl_value(arr));
+  tmp=rb_str_dup(rb_iv_get(self,"@name"));
+  tmp=rb_str_cat2(tmp,"=_ruby_export_");
+  cmd=StringValuePtr(tmp);
+  // printf("cmd=%s\n",cmd);
+  // jl_eval_string("show(_ruby_export_)");
+  // printf("cmd->done\n");
+  jl_eval_string(cmd);
+  return self;
+}
+
+VALUE JuliaVect_assign(VALUE obj, VALUE name,VALUE arr)
+{
+  jl_value_t* ans;
+  char *tmp;
+
+  ans=util_VALUE_to_jl_value(arr);
+
+  tmp = StringValuePtr(name);
+  jl_set_global(jl_main_module, jl_symbol(tmp),ans);
+
+  return Qnil;
+}
+
+VALUE JuliaVect_set_with_arg(VALUE self,VALUE arr)
+{
+  VALUE tmp;
+  char *cmd;
+  // defineVar(install(".rubyExport"),util_VALUE2jl_value_t*(arr),R_GlobalEnv);
+  // tmp=rb_iv_get(self,"@arg");
+  // util_eval1string(rb_str_cat2(rb_str_cat2(rb_str_dup(rb_iv_get(self,"@name")),StringValuePtr(tmp)),"<-.rubyExport"));
+  jl_set_global(jl_main_module, jl_symbol("_ruby_export_"),util_VALUE_to_jl_value(arr));
+  tmp=rb_str_dup(rb_iv_get(self,"@arg"));
+  tmp=rb_str_cat2(rb_str_dup(rb_iv_get(self,"@name")),StringValuePtr(tmp));
+  tmp=rb_str_cat2(tmp,"=_ruby_export_");
+  cmd=StringValuePtr(tmp);
+  jl_eval_string(cmd);
+  return self;
+}
+
+void
+Init_jl4rb()
+{
+  VALUE mJulia;
+
+  mJulia = rb_define_module("Julia");
+
+  rb_define_module_function(mJulia, "initJL", Julia_init, 1);
+
+  rb_define_module_function(mJulia, "evalLine", Julia_eval, 2);
+
+  rb_define_module_function(mJulia, "execLine", Julia_exec, 2);
+
+  VALUE cJuliaVect;
+
+  cJuliaVect = rb_define_class_under(mJulia,"Vector",rb_cObject);
+
+  rb_define_module_function(cJuliaVect, "assign", JuliaVect_assign, 2);
+
+  rb_define_method(cJuliaVect,"initialize",JuliaVect_initialize,1);
+
+  rb_define_method(cJuliaVect,"get",JuliaVect_get,0);
+  rb_define_alias(cJuliaVect,"to_a","get");
+  rb_define_alias(cJuliaVect,"value","get");
+
+  rb_define_method(cJuliaVect,"set",JuliaVect_set,1);
+  rb_define_alias(cJuliaVect,"<","set");
+  rb_define_alias(cJuliaVect,"value=","set");
+
+  //method "arg=" defined in eval.rb!! @arg initialized in method "initialize"
+  rb_define_method(cJuliaVect,"get_with_arg",JuliaVect_get_with_arg,0);
+  rb_define_alias(cJuliaVect,"value_with_arg","get_with_arg");
+  rb_define_method(cJuliaVect,"set_with_arg",JuliaVect_set_with_arg,1);
+  rb_define_alias(cJuliaVect,"value_with_arg=","set_with_arg");
+
+  rb_define_method(cJuliaVect,"valid?",JuliaVect_isValid,0);
+  rb_define_method(cJuliaVect,"length",JuliaVect_length,0);
+  //rb_define_method(cJuliaVect,"[]",JuliaVect_aref,1);
+
+  rb_define_attr(cJuliaVect,"name",1,1);
+  rb_define_attr(cJuliaVect,"type",1,1);
+
+}

data/jl4rb.gemspec

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'rubygems/package_task'
+
+PKG_NAME='jl4rb'
+PKG_VERSION='0.0.4'
+PKG_FILES=FileList[
+    'Rakefile','jl4rb.gemspec',
+    'ext/jl4rb/*.c',
+    'ext/jl4rb/extconf.rb',
+    'ext/jl4rb/*.h',
+    'ext/jl4rb/MANIFEST',
+    'lib/**/*.rb',
+    'test/**/*.rb'
+]
+
+Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Julia for ruby"
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.requirements << 'none'
+  s.require_paths = ["lib","ext/jl4rb"]
+  s.files = PKG_FILES.to_a
+  s.extensions = ["ext/jl4rb/extconf.rb"]
+  s.licenses = ['MIT', 'GPL-2']
+  s.description = <<-EOF
+R is embedded in ruby with some communication support .
+EOF
+  s.author = "CQLS"
+  s.email= "rdrouilh@gmail.com"
+  s.homepage = "http://cqls.upmf-grenoble.fr"
+  s.rubyforge_project = nil
+end

data/lib/jl4rb/jl2rb_eval.rb

@@ -0,0 +1,128 @@
+## Module Julia
+
+module Julia
+  # Careful!, Julia.exec code, :get => nil does not fetch stdout
+  def Julia.eval(s,opts={})
+    opts={:print=>true,:show=>nil,:simplify=>true,:init=>true,:safe=>true}.merge(opts)
+    #p opts
+    Julia.init if opts[:init] #just in case
+    res=[]
+    input,output="",""
+    s=[s] unless s.is_a? Array
+    s.each_with_index do |line,i| #line here is a command!
+      input << line        
+      output=evalLine input, opts[:print]
+      if output.is_a? String and output[0...12]=="__incomplete"
+        if i==s.length - 1 #last!
+          res << {:in => input, :out => output} unless input.empty?
+        else
+          input << "\n"
+        end
+      else
+        res << {:in => input, :out => output}
+        input=""
+      end
+    end
+    if opts[:show]
+      res.each do |cmd|
+        print "in > ";puts cmd[:in]
+        begin print "out> ";puts cmd[:out];end unless  cmd[:out]=="__incomplete__"
+      end
+    else
+      res=res[0][:out] if res.length==1 and opts[:simplify]
+      return res
+    end
+  end
+
+  # Careful!, Julia.exec code, :get => nil does not fetch stdout
+  def Julia.exec(code,opts={})
+    opts={:get=>true}.merge(opts)
+    execLine code, opts[:get]
+  end
+
+  def Julia.<(s)
+    Julia.exec(s)
+  end
+
+  def Julia.<<(s)
+    Julia.eval(s)
+  end
+
+  class Vector
+
+    def <<(name)
+      if name.is_a? Symbol
+        @name=name.to_s
+        @type="var"
+      else
+        @name=name
+        @type="expr"
+      end
+      return self
+    end
+
+    def arg=(arg)
+      @arg=arg
+    end
+
+    #this method is the same as the previous one but return self! Let us notice that even by adding return self in the previous one
+    # I could not manage to execute (rvect.arg="[2]").value_with_arg but fortunately rvect.set_arg("[2]").value_with_arg is working!
+    def set_arg(arg)
+      @arg=arg
+      return self
+    end
+
+    def [](key)
+      set_arg("["+(key+1).to_s+"]")
+      get_with_arg
+    end
+
+    def []=(key,val)
+      set_arg("["+(key+1).to_s+"]")
+      set_with_arg(val)
+    end
+   
+    def >(arr)
+      res=self.get
+#puts "res";p @name;p res
+      if res
+#puts "arr.class:";p arr.class
+#puts "res.class";p res.class
+        res=[res] unless res.is_a? Array
+        arr.replace(res)
+      else
+        arr.clear
+      end
+      return self
+    end
+
+=begin #Done directly inside R4rb.c
+    def value_with_arg(arg)
+      old_name,old_type=@name.dup,@type.dup
+      @name,@type=@name+arg,"expr"
+      value
+      @name,@type=old_name,old_type
+    end
+=end
+
+  end
+
+end
+
+module JL
+  def JL.<<(s)
+    Julia << s
+  end
+end
+
+
+
+class String
+
+  def jl4rb
+    Julia << self
+  end
+
+  alias to_jl jl4rb
+end
+ 

data/lib/jl4rb/jl2rb_init.rb

@@ -0,0 +1,15 @@
+module Julia
+
+  def Julia.init(args={})
+    unless Julia.alive?
+      args={:img=>File.join(ENV["JULIA_DIR"],"lib")}.merge(args) if ENV["JULIA_DIR"]
+      args={:img=>ENV["JULIA_IMG_DIR"]}.merge(args) if ENV["JULIA_IMG_DIR"]
+      @@initJL=Julia.initJL([args[:img]])
+    end 
+  end
+
+  def Julia.alive?
+    defined? @@initJL
+  end
+
+end

data/lib/jl4rb.rb

@@ -0,0 +1,6 @@
+require 'jl4rb.bundle' if File.exists? File.join(File.dirname(__FILE__),'jl4rb.bundle') 
+require 'jl4rb.so' if File.exists? File.join(File.dirname(__FILE__),'jl4rb.so')
+
+# loading ruby files
+require 'jl4rb/jl2rb_init'
+require 'jl4rb/jl2rb_eval'

data/test/testDynArray.rb

@@ -0,0 +1,14 @@
+require 'R4rb'
+require 'jl4rb'
+require File.expand_path("~/Github/dyndoc/lib/dyndoc/common/dynArray")
+
+Array.initR
+Julia.init
+
+a=[] < 'jl:[2*i for i=1:4]'
+
+p a
+
+a > 'R:b'
+
+R4rb << 'print(b)' 

data/test/testJLVector.rb

@@ -0,0 +1,31 @@
+require 'jl4rb'
+
+Julia.init
+
+# julia variable
+if true
+	aa=Julia::Vector.new "a"
+
+	aa < [1,4,3]
+
+	p "a".to_jl
+
+	Julia << "a=[4,7,3,9]"
+
+	p aa.value
+end
+
+if true
+	Julia << "b=Dict()"
+
+	bb=Julia::Vector.new ""
+	bb << 'b["toto"]'
+
+	bb < [1,4,66]
+
+	p 'b["toto"]'.to_jl
+
+	Julia << 'b["toto"]=[4,7,3,99]'
+
+	p bb.value
+end

data/test/testWithArg.rb

@@ -0,0 +1,25 @@
+require 'jl4rb'
+
+Julia.init
+
+aa=Julia::Vector.new "a"
+
+aa < [1,4,3]
+
+p "a".to_jl
+
+# In ruby
+p aa[1]
+
+# In Julia
+aa.set_arg("[2]")
+
+p aa.get_with_arg
+
+aa.set_with_arg (12)
+
+p "a".to_jl
+
+aa[1]=33.0
+
+p "a".to_jl

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: jl4rb
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- CQLS
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-14 00:00:00.000000000 Z
+dependencies: []
+description: |
+  R is embedded in ruby with some communication support .
+email: rdrouilh@gmail.com
+executables: []
+extensions:
+- ext/jl4rb/extconf.rb
+extra_rdoc_files: []
+files:
+- Rakefile
+- jl4rb.gemspec
+- ext/jl4rb/jl4rb.c
+- ext/jl4rb/extconf.rb
+- ext/jl4rb/MANIFEST
+- lib/jl4rb.rb
+- lib/jl4rb/jl2rb_eval.rb
+- lib/jl4rb/jl2rb_init.rb
+- test/testDynArray.rb
+- test/testJLVector.rb
+- test/testWithArg.rb
+homepage: http://cqls.upmf-grenoble.fr
+licenses:
+- MIT
+- GPL-2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext/jl4rb
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- none
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Julia for ruby
+test_files: []