carray-dataframe 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7f93c348e3fd8e166ddba89d5ddc1f0fb86653a6
-  data.tar.gz: cb16a824a9e0c2aaf40db3f26328176ef9eb882e
+SHA256:
+  metadata.gz: c0561562238eb969944e6e7977f3cdc4edbe3370187ea1f7ba01a2f6af60bf40
+  data.tar.gz: 738a716a1b5055fefb8b182dd26a3a9ac559563072b02df151bf16eab652f245
 SHA512:
-  metadata.gz: 8f96c5cf91470a732a09aa1e3629b94963d29d786dbfa9768430c18e0ebe1b2219f7256ddc17c783ce8cac9253c19c4cbce9e16d005435f0f718f97c788b832d
-  data.tar.gz: b982e8a4b8f162f69bb86fd31d0d92d1d86c7c06b663b9cc091974fe46fcdbf16635e3e793cc91b813fd54cff29e7135416c449ba0089985332dad354d2a18a9
+  metadata.gz: 320b6326fb40b111bc601c38d0e2a5a917434dedfd96f9830c4d24dd66df507d7450d30027829f2a832c0673c69bbe20cb7bb5201adad4cc41728505ecbea9d3
+  data.tar.gz: 4bd51f6c826a561dbb108aa57988520ca870fc02d8615babaa65644ca4869dd781b48c6015b19ba5235943fa7d793d0789ced918ae3675b9f4ae3aef0eb0aaf7

data/API.txt

@@ -24,16 +24,14 @@ df["AAA"]               => 1 dimensional CArray
 df[["AAA"]].to_ca       => 2 dimensional CArray with column_names
 df[["AAA","BBB"]].to_ca => 2 dimensional CArray with column_names
 
-
 df[dfmask] 
   return new detached CADataFrame masked where dfmask's value equal 1
 
-
 ### Iterators
 
 CADataFrame#each_column_name { |name| ... }
 CADataFrame#each_column { |name, column| ... }
-CADataFrame#each_row(with: [Array|Hash]) { |row| ... }
+CADataFrame#each_row(with: [Array|Hash|CArray]) { |row| ... }
 CADataFrame#each_row_with_row_index(with: [Array|Hash]) { |row, idx| ... }
 
 ### Transformation
@@ -43,7 +41,6 @@ CADataFrame#add_suffix(suffix_string) -> CADataFrame
 
 CADataFrame#transpose(column_names: )
 
-
 ### Conversion
 
 CADataFrame#ca      -> CADFArray (Reference Array)
@@ -67,9 +64,6 @@ ex) df.columns_to_hash("bbb",["aaa","ccc"])
 
   {10=>[4, 100], 20=>[5, 50], 30=>[6, -30], 40=>[7, -50]}
 
-
-
-
 CADataFrame 
  
 #append(name) { INSTANCE_CONTEXT }    <- any carray

data/README.md

@@ -1,5 +1,7 @@
 carray-dataframe
 ================
 
-
 gem install rsruby
+
+
+

data/Rakefile

@@ -0,0 +1,11 @@
+GEMSPEC = "carray-dataframe.gemspec"
+
+task :install do
+  spec = eval File.read(GEMSPEC)
+  system %{
+    gem build #{GEMSPEC}; gem install #{spec.full_name}.gem
+  }
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new

data/carray-dataframe.gemspec

@@ -1,25 +1,27 @@
 
 Gem::Specification::new do |s|
-  version = "1.0.0"
+  version = "1.1.1"
 
   files = Dir.glob("**/*") - [ 
-                               Dir.glob("carray*.gem"), 
+                               Dir.glob("carray-dataframe*.gem"), 
+                               Dir.glob("examples/**/*"), 
+                               Dir.glob("test/**/*"), 
                              ].flatten
 
   s.platform    = Gem::Platform::RUBY
   s.name        = "carray-dataframe"
-  s.summary     = "Extension for realizing DataFrame of R in Ruby"
+  s.summary     = "DataFrame in Ruby"
   s.description = <<-HERE
-    Extension for realizing DataFrame of R in Ruby
+    DataFrame in Ruby
   HERE
   s.version     = version
   s.author      = "Hiroki Motoyoshi"
   s.email       = ""
   s.homepage    = 'https://github.com/himotoyoshi/carray-dataframe'
+  s.license     = 'MIT'
   s.files       = files
-  s.has_rdoc    = false
   s.required_ruby_version = ">= 1.8.1"
-  s.add_runtime_dependency 'carray', '~> 1.1'
+  s.add_runtime_dependency 'carray', '~> 1.5'
   s.add_runtime_dependency 'axlsx', '~> 2.0'
   s.add_runtime_dependency 'spreadsheet', '~> 1.1'
 end

data/lib/carray-dataframe.rb

@@ -0,0 +1,13 @@
+require "carray-timeindex"
+require "carray-dataframe/dataframe"
+require "carray-dataframe/reference"
+require "carray-dataframe/loc_accessor"
+require "carray-dataframe/iloc_accessor"
+require "carray-dataframe/arranger"
+require "carray-dataframe/cadf_array"
+require "carray-dataframe/group"
+require "carray-dataframe/pivot"
+require "carray-dataframe/join"
+require "carray-dataframe/io"
+require "carray-dataframe/converter"
+require "carray-dataframe/to_html"

data/lib/carray-dataframe/arranger.rb

@@ -0,0 +1,209 @@
+#############################################################
+#
+# ARRANGER
+#
+#############################################################
+class CADataFrame
+  class Arranger
+
+    def initialize (dataframe)
+      @dataframe = dataframe
+    end
+
+    def arrange (&block)
+      case block.arity
+      when 1
+        instance_exec(@dataframe, &block)
+      else
+        instance_exec(&block)
+      end
+      return @dataframe
+    end
+    private
+
+    def index
+      return @dataframe.index
+    end
+
+    def column_names
+      return @dataframe.column_names
+    end
+
+    def row_number
+      return @dataframe.row_number
+    end
+
+    def row_index
+      return @dataframe.row_index
+    end
+
+    def method (hash)
+      @dataframe.method(hash)
+    end
+
+    def timeseries (name, format)
+      time_column = @dataframe.columns[name.to_s]
+      column = CATimeIndex.from_time_array(time_column, "sec", format: format)
+      @dataframe.columns[name.to_s] = column
+    end
+
+    def timeindex (name, unit: "second", since: nil, offset: nil, format: nil)
+      time_column = @dataframe.columns[name.to_s]
+      column = CATimeIndex.from_time_array(time_column, unit, since: since, format: format, offset: offset)
+      @dataframe.columns[name.to_s] = column
+    end
+
+    def type (type, name, mask = :novalue)
+      @dataframe.columns[name.to_s] = @dataframe.columns[name.to_s].to_type(type)
+      if mask != :novalue
+        @dataframe.columns[name.to_s].maskout!(options[:maskout])
+      end
+    end
+
+    def eliminate (*names)
+      if names.empty?
+        return self
+      end
+      names = names.map(&:to_s)
+      @dataframe.column_names.clone.each do |name|
+        if names.include?(name)
+          @dataframe.columns.delete(name)
+          @dataframe.column_names.delete(name)
+        end
+      end
+    end
+    
+    alias drop eliminate
+
+    def template (*args, &block)
+      return @dataframe.columns.first[1].template(*args, &block)
+    end
+
+    def double (*names)
+      names.flatten.map(&:to_s).each do |name|
+        if @dataframe.column_names.include?(name)
+          type(:double, name)
+        else
+          raise "Unknown column name '#{name}'"
+        end
+      end
+    end
+
+    def int (*names)
+      names.flatten.map(&:to_s).each do |name|
+        if @dataframe.column_names.include?(name)
+          type(:int, name)
+        else
+          raise "Unknown column name '#{name}'"
+        end
+      end
+    end
+
+    def maskout (value, *names)
+      warn "maskout is obsolete. use mask(name, *values)"
+      names.flatten.map(&:to_s).each do |name|
+        @dataframe.columns[name].maskout!(value)
+      end
+    end
+
+    def mask (name, *values)
+      column = @dataframe.columns[name.to_s]
+      values.each do |args|
+        if args.nil?
+          column.maskout!(nil)
+        else
+          column.maskout!(*args)
+        end
+      end
+    end
+
+    def unmask (value, *names)
+      names.flatten.map(&:to_s).each do |name|
+        @dataframe.columns[name].unmask(value)
+      end
+    end
+
+    def col (name)
+      return @dataframe.col(name)
+    end
+
+    def append (name, new_column)
+      if new_column
+        # do nothing
+      else
+        new_column = @dataframe.columns.first[1].template(:object)
+      end
+      unless new_column.is_a?(CArray)
+        new_column = new_column.to_ca
+      end
+      @dataframe.columns[name.to_s] = new_column
+      @dataframe.column_names.push(name.to_s)
+    end
+
+    def prepend (name, new_column)
+      if new_column
+        # do nothing
+      else
+        new_column = @dataframe.columns.first[1].template(:object)
+      end
+      unless new_column.is_a?(CArray)
+        new_column = new_column.to_ca
+      end
+      @dataframe.columns[name.to_s] = new_column
+      @dataframe.column_names.unshift(name.to_s)
+    end
+    alias lead prepend
+
+    def rename (name1, name2)
+      if idx = @dataframe.column_names.index(name1.to_s)
+        @dataframe.column_names[idx] = name2.to_s
+        column = @dataframe.columns[name1.to_s]
+        @dataframe.columns.delete(name1.to_s)
+        @dataframe.columns[name2.to_s] = column
+      else
+        raise "unknown column name #{name1}"
+      end
+    end
+
+    def downcase
+      @dataframe.downcase
+    end
+
+    def classify (name, scale, opt = {})
+      return @dataframe.classify(name, scale, opt)
+    end
+
+    def map (mapper, name_or_column)
+      case name_or_column
+      when String, Symbol
+        name = name_or_column
+        column = @dataframe.columns[name.to_s]
+      when CArray
+        column = name_or_column
+      when Array
+        column = name_or_column.to_ca
+      else
+        raise "invalid argument"
+      end
+      case mapper
+      when Hash
+        return column.convert(:object) {|v| hash[v] }
+      when CArray
+        return mapper.project(column)
+      when Array
+        return mapper.to_ca.project(column)
+      end
+    end
+
+    def method_missing (name, *args)
+      if args.size == 0
+        if @dataframe.column_names.include?(name.to_s)
+          return @dataframe.columns[name.to_s]
+        elsif @dataframe.__methods__.include?(name.to_s)
+          return @dataframe.columns[@dataframe.__methods__[name.to_s]]
+        end
+      end
+      super
+    end
+  end
+end

data/lib/carray-dataframe/cadf_array.rb

@@ -0,0 +1,106 @@
+#############################################################
+#
+# CADFArray
+#
+#############################################################
+class CADFArray < CAObject # :nodoc:
+
+  def initialize (column_names, column_data, index: nil)
+    @column_names = column_names
+    @column_data  = column_data
+    if index
+      @index = index
+    else
+      @index = CArray.int(column_data.first[1].size).seq
+    end
+    dim = [@column_data[@column_names.first].size, @column_names.size]
+    extend CArray::TableMethods
+    super(:object, dim, :read_only=>true)
+    __create_mask__
+  end
+  
+  attr_reader :column_names, :index
+
+  def fetch_index (idx)
+    r, c = *idx
+    name = @column_names[c]
+    return @column_data[name].value[r]
+  end
+
+  def store_index (idx, value)
+    r, c = *idx
+    name = @column_names[c]
+    return @column_data[name][r] = value
+  end
+
+  def copy_data (data)
+    @column_names.each_with_index do |name, i|
+      data[nil,i] = @column_data[name].value
+    end
+  end
+
+  def sync_data (data)
+    @column_names.each_with_index do |name, i|
+      @column_data[name].value[] = data[nil,i]
+    end
+  end
+
+  def fill_data (value)
+    @column_names.each do |name|
+      @column_data[name] = value
+    end
+  end
+
+  def create_mask
+    @column_names.each do |name|
+       @column_data[name].instance_eval{ __create_mask__ }
+    end
+  end
+
+  def mask_fetch_index (idx)
+    r, c = *idx
+    name = @column_names[c]
+    if @column_data[name].has_mask?
+      return @column_data[name].mask[r]
+    else
+      return 0
+    end
+  end
+
+  def mask_store_index (idx, value)
+    r, c = *idx
+    name = @column_names[c]
+    if @column_data[name].has_mask?
+      return @column_data[name].mask[r] = value
+    else
+      @column_data[name].mask[r] = value
+    end
+  end
+
+  def mask_copy_data (data)
+    @column_names.each_with_index do |name, i|
+      if @column_data[name].has_mask?
+        data[nil,i] = @column_data[name].mask
+      end
+    end
+  end
+
+  def mask_sync_data (data)
+    @column_names.each_with_index do |name, i|
+      @column_data[name].mask[] = data[nil,i]
+    end
+  end
+
+  def mask_fill_data (value)
+    @column_names.each do |name|
+      @column_data[name].mask[] = value
+    end
+  end
+
+  def to_ca
+    obj = super
+    obj.extend CArray::TableMethods
+    obj.column_names = @column_names
+    return obj
+  end
+end

data/lib/carray-dataframe/converter.rb

@@ -0,0 +1,97 @@
+
+module CArray::TableMethods
+
+  def to_dataframe (index: nil, &block)
+    if self.size == 0
+      return nil
+    end
+    df = CADataFrame.new(self, index: index, &block)
+    if @header or @note
+      df.instance_variable_set(:@header, @header)
+      df.instance_variable_set(:@note, @note)
+      class << df
+        attr_reader :note
+
+        def header (name=nil)
+          if name
+            return @header[name.to_s]
+          else
+            return @column_names
+          end
+        end
+      end
+    end
+    return df
+  end
+  alias to_df to_dataframe
+end
+
+class CADataFrame
+
+  def to_a (with_index: true)
+    if @row_index and with_index
+      namelist = [""] + @column_names
+      tbl = CADFArray.new(namelist, @column_data.clone.update("" => index))
+    else
+      tbl = ca.to_ca
+    end
+    return tbl.to_a
+  end
+
+  def to_csv (io = "", rs: $/, sep: ",", fill: "", with_index: true, time_format: nil, &block)
+    if @row_index and with_index
+      namelist = ["index"] + @column_names
+      columns = @column_data.clone.update("index" => index)
+    else
+      namelist = @column_names
+      columns = @column_data.clone
+    end
+    columns.each do |k, v|
+      if v.is_a?(CATimeIndex)
+        if time_format
+          columns[k] = v.time.time_format(time_format)
+        else
+          columns[k] = v.time.convert(:object){|t| t.to_s}
+        end
+      end
+    end
+    tbl = CADFArray.new(namelist, columns)
+    return tbl.to_csv(io, **{rs: rs, sep: sep, fill: fill}, &block)
+  end
+
+  def to_daru
+    require "daru"
+    columns = {}
+    each_column_name do |name|
+      columns[name] = column(name).object.unmask(nil).to_a
+    end
+    if @row_index
+      return Daru::DataFrame.new(columns, index: @row_index.to_a, order: @column_names)
+    else
+      return Daru::DataFrame.new(columns, order: @column_names)
+    end
+  end
+
+  def to_xlsx (filename, sheet_name: 'Sheet1', with_row_index: false, &block)
+    require "axlsx"
+    xl = Axlsx::Package.new
+    xl.use_shared_strings = true
+    sheet = xl.workbook.add_worksheet(name: sheet_name)
+    df = self.to_df.objectify.unmask("=NA()")
+    if with_row_index
+      sheet.add_row([""] + column_names)
+      df.each_row_with_row_index(with: Array) do |list, i|
+        sheet.add_row([i] + list)
+      end
+    else
+      sheet.add_row(column_names)
+      df.each_row(with: Array) do |list|
+        sheet.add_row(list)
+      end
+    end
+    if block_given?
+      yield sheet
+    end
+    xl.serialize(filename)
+  end
+end