carray-dataframe 1.0.0

data/examples/test2.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+require "carray"
+require_relative "../lib/carray/dataframe/dataframe"
+
+
+hash =   { '温度' => [4,5,6,7], '湿度' => [10,20,30,40], '気圧差' => [100,50,-30,-50] }
+df = CADataFrame.new(hash) {
+  double :温度, :湿度
+}
+
+p df
+
+p df.温度
+p df.湿度

data/examples/test3.rb

@@ -0,0 +1,11 @@
+require "carray"
+require_relative "../lib/carray/dataframe/dataframe"
+
+hash =   { '番号' => [4,5,6,7], 'bbb' => [10,20,30,40], 'ccc' => [100,50,-30,-50] }
+p df = CADataFrame.new(hash)
+
+df.select{ (番号 % 2).eq(1) }[] = UNDEF
+
+df.to_xlsx("test3.xlsx", with_row_index: true)
+df.to_df.unmask(-999).to_sqlite3(database: "test3.db", table: "test")
+

data/examples/to_excel.rb

@@ -0,0 +1,27 @@
+require "carray"
+
+df = CADataFrame.new :a=>[1,2,3,4,5,6,7,8,9,10]
+df.arrange {
+  append :b, a**2  
+  append :c, a.template(:object).seq("A", :succ)
+}
+
+df.to_xlsx("test.xlsx") {|sheet|
+  sheet.add_chart(Axlsx::ScatterChart, :start_at => [5,2], :end_at => [10, 15], :title => "Chart") do |chart|
+    chart.add_series :xData => sheet["A2:A11"], 
+                     :yData => sheet["B2:B11"], 
+                     :labels => sheet["C2:C11"], 
+                     :title => 'bob'
+  end
+}
+
+__END__
+xl = Axlsx::Package.new
+xl.use_shared_strings = true
+sheet = xl.workbook.add_worksheet(name: 'Example')
+sheet.add_row(df.column_names)
+df.each_row do |list|
+  sheet.add_row(list)
+end
+
+  endxl.serialize("test.xlsx")

data/lib/R.rb

@@ -0,0 +1,365 @@
+require "rsruby"
+require "rsruby/erobj"
+require "carray"
+
+class RSRuby
+  
+  #Converts a String representing a 'Ruby-style' R function name into a 
+  #String with the real R name according to the rules given in the manual.
+  def RSRuby.convert_method_name (name)
+    if name.length > 1 and name[-1].chr == '_' and name[-2].chr != '_'
+      name = name[0..-2]
+    end
+    name = name.gsub(/__/,'<-')
+    name = name.gsub(/_/, '.')
+    return name
+  end
+  
+end
+
+def R (expr = nil, hash = {}, &block)
+  if block
+    if expr
+      raise "don't give both of block and expresion"
+    else
+      R.instance_exec(&block)
+    end
+  else
+    return R.call(expr, hash)
+  end
+end
+
+def R! (expr = nil, hash = {}, &block)
+  if block
+    if expr
+      raise "don't give both of block and expresion"
+    else
+      R.instance_exec(&block)
+    end
+	elsif expr.is_a?(Hash)
+		expr.each do |name, value|
+			R.instance.assign name.to_s, value
+		end
+  else
+    return R.exec(expr, hash)
+  end
+end
+
+module R
+
+  class Receiver < ::ERObj
+
+    def initialize (klass, x)
+      @classname  = klass
+      @attributes = R(%{ attributes(obj) },:obj=>x)
+      super(x)
+    end
+
+    attr_reader :attributes, :robj
+
+    def [] (sym = nil)
+      if sym
+        name = sym.to_s
+        name = name.gsub(/_/, '.')
+        begin
+          ret = @r['$'].call(@robj, name)
+        rescue RException
+          ret = @attributes[name]
+        end
+        return __converter__(ret)
+      else
+        return __converter__(to_ruby)
+      end
+    end
+
+    def __converter__ (arg)
+      case arg
+      when Array
+        return arg.to_ca.map!{|v| __converter__(v) }
+      when Hash
+        new_hash = {}
+        arg.each do |k,v|
+          new_hash[k] = __converter__(v)
+        end
+        return new_hash
+      when RObj
+        return R::CONVERTER[arg]
+      else
+        return arg
+      end
+    end
+        
+    def method
+      return self[:method]
+    end
+
+    def inspect
+      return "<R:Receiver: class=#{@classname} \n" \
+             "             attributes=#{@attributes.inspect} \n" \
+             "             data=#{to_ruby} >"
+    end
+
+    def method_missing (sym, *args)
+      if args.empty?
+        return self[sym]
+      else
+        super
+      end
+    end
+      
+    def to_ary
+      return [self.to_s]
+    end
+      
+  end
+
+  CONVERSION_TABLE = {
+    "data.frame" => lambda{ |x| CADataFrame.from_R_data_frame(x) },
+    "ts" => lambda{ |x| R::TimeSeries.new(x) },
+  }
+
+  CONVERTER = lambda{|x| 
+    case x
+    when RObj
+      klass = @r.eval_R("class").call(x)
+      if CONVERSION_TABLE.has_key?(klass)
+        CONVERSION_TABLE[klass][x]
+      else
+        case val = x.to_ruby
+        when Numeric, String
+          val
+        when Hash, NilClass
+          Receiver.new(klass, x)
+        when Array
+          val = val.to_ca
+          case klass
+          when "character", "factor"
+            val = val.maskout!(R.NA_character_)
+          when "integer"
+            val = val.maskout!(R.NA_integer_).int32
+          when "numeric"
+            val = val.maskout!(R.NA_real_).double
+          end
+          val
+        else
+          val
+        end
+      end
+    else 
+      x
+    end
+  }
+
+  def self.run
+    if @r
+      return nil
+    end
+    ENV["LANG"]   = "en_US.UTF-8"
+    ENV["LC_ALL"] = "en_US.UTF-8"
+    @r = RSRuby.instance
+    RSRuby.set_default_mode(RSRuby::PROC_CONVERSION)
+    @r.class_table['data.frame'] = lambda{|x| ERObj.new(x) }
+    @r.class_table['matrix'] = lambda{|x| ERObj.new(x) }
+    @r.proc_table[lambda{|x| true }] = CONVERTER
+    @NA_integer_   = R %{ NA_integer_ }
+    @NA_real_      = R %{ NA_real_ }
+    @NA_character_ = R %{ NA_character_ }
+    ObjectSpace.define_finalizer(self, proc{ @r.shutdown })
+    return nil
+  end
+  
+  def self.stop
+    @r.shutdown
+    @r = nil
+  end
+
+  class << self
+    attr_reader :NA_integer_, :NA_real_, :NA_character_
+  end
+
+  def self.instance
+    return @r
+  end
+
+  def self.exec (expr, hash = {})
+    hash.each do |name, value|
+      @r.assign(name.to_s, __converter__(value))
+    end
+    return @r.eval_R(expr)
+  end
+
+  def self.call (expr, hash = {})
+    names = ["DU33Y"]
+    args  = [0]
+    hash.each do |name, value|
+      names.push(name.to_s)
+      args.push(__converter__(value))
+    end
+    expr = "function (#{names.join(",")}) {" + expr + "}"
+    return @r.eval_R(expr).call(*args)
+  end
+
+  def self.__converter__ (arg)
+    case arg
+    when Symbol
+      return arg.to_s
+    when CArray
+      return __converter__(arg.as_r)
+    when CADataFrame
+      return arg.as_r
+    when Array
+      return arg.map{|v| __converter__(v) }
+    when Hash
+      new_hash = {}
+      arg.each do |k,v|
+        new_hash[k] = __converter__(v)
+      end
+      return new_hash
+    else
+      return arg
+    end
+  end
+
+  def self.method_missing (sym, *args)
+    if args.empty? and sym.to_s[-1] == "!"
+      return @r.send(sym.to_s[0..-2].intern).call()
+    elsif args.size == 1 and sym.to_s[-1] == "="
+      return @r.assign(sym.to_s[0..-2], __converter__(args[0]))
+    else
+      return @r.send(sym, *args.map{|v| __converter__(v)})
+    end
+  end
+
+end
+
+class CArray
+
+  def guess_column_type_for_R 
+    if is_a?(CArray)
+      if integer?
+        "integer"
+      elsif float?
+        "numeric"
+      elsif object?
+        notmasked = self[:is_not_masked].to_ca
+        if notmasked.convert(:boolean){|v| v.is_a?(Integer) }.all_equal?(1)
+          "integer"
+        elsif notmasked.convert(:boolean){|v| v.is_a?(Numeric) }.all_equal?(1)
+          "numeric"
+        elsif notmasked.convert(:boolean){|v| v.is_a?(String) }.all_equal?(1)
+          "character"
+        else
+          "unknown"
+        end
+      end
+    else
+      raise "invalid column name"
+    end
+  end
+
+  def as_r
+    if has_mask?
+      case guess_column_type_for_R
+      when "integer"
+        out = unmask_copy(R.NA_integer_)
+      when "numeric"
+        out = unmask_copy(R.NA_real_)
+      else
+        out = unmask_copy(R.NA_character_)
+      end
+		else
+			out = self
+    end
+	  if rank == 1
+      return out.to_a
+    elsif rank == 2
+			begin
+		    mode = RSRuby.get_default_mode
+	      RSRuby.set_default_mode(RSRuby::NO_CONVERSION)
+	      return R.matrix(out.flatten.to_a, :nrow=>dim0)
+	    ensure
+	      RSRuby.set_default_mode(mode)
+	    end
+		else
+			return out.to_a
+		end
+  end
+
+end
+
+class CADataFrame
+
+  def self.from_R_data_frame (obj)
+    r = R.instance
+    RSRuby.set_default_mode(RSRuby::PROC_CONVERSION)
+    r.proc_table[lambda{|x| true }] = R::CONVERTER
+    dataframe = obj
+    column_names = r.colnames(obj).to_a
+    column_names = [column_names].flatten
+    row_names = r.attr(obj, 'row.names')
+    columns = {}
+    column_names.each do |name|
+      value = r['$'].call(obj, name.to_s)
+      case value
+      when CArray
+        columns[name] = value
+      when Array
+        columns[name] = value.to_ca        
+      else
+        columns[name] = [value].to_ca
+      end
+    end
+    column_names.each do |name|
+      column = columns[name]
+      column.maskout!(nil)
+    end
+    return CADataFrame.new(columns, row_index: row_names ? row_names.to_ca : nil)
+  end
+
+  def as_r
+    r = R.instance
+    new_columns = {}
+    @column_names.each do |name|
+      column = @columns[name]
+      if column.has_mask?
+        case column.guess_column_type_for_R
+        when "integer"
+          column = column.unmask_copy(R.NA_integer_)
+        when "numeric"
+          column = column.unmask_copy(R.NA_real_)
+        else
+          column = column.unmask_copy(R.NA_character_)
+        end
+      end
+      new_columns[name] = R.__converter__(column.to_a)
+    end
+    mode = RSRuby.get_default_mode
+     RSRuby.set_default_mode(RSRuby::NO_CONVERSION)
+    return r.as_data_frame(:x => new_columns)
+  ensure
+    RSRuby.set_default_mode(mode)
+  end
+
+end
+
+class R::TimeSeries < ERObj
+  
+  def start
+    return R.start(self)
+  end
+  
+  def end
+    return R.end(self)
+  end
+  
+  def frequency
+    return R.frequency(self)
+  end
+  
+  def length
+    return R.length(self)
+  end
+    
+end
+
+

data/lib/carray/autoload/autoload_dataframe_dataframe.rb

@@ -0,0 +1,26 @@
+
+module CA::TableMethods
+  autoload_method "to_df", "carray/dataframe/dataframe"
+end
+
+autoload :CADataFrame, "carray/dataframe/dataframe"
+
+autoload :DataFrame, "carray/dataframe/dataframe"
+autoload :RSReceiver, "carray/dataframe/dataframe"
+
+class RSRuby
+  autoload_method "setup", "carray/dataframe/dataframe"
+  autoload_method "recieve", "carray/dataframe/dataframe"
+end
+
+module Daru
+  class DataFrame
+    autoload_method "to_df", "carray/dataframe/dataframe"
+  end
+end
+
+module SQLite3
+  class Database
+    autoload_method "to_df", "carray/dataframe/dataframe"
+  end
+end