carray-dataframe 1.0.0 → 1.1.1

data/lib/carray-dataframe/loc_accessor.rb

@@ -0,0 +1,145 @@
+class CADataFrame
+  
+  class LocAccessor
+
+    def initialize (dataframe)
+      @dataframe = dataframe
+    end
+
+    def [] (*argv)
+      @dataframe.instance_eval {
+        index = argv.first
+        case index
+        when nil
+        when CArray
+        when Integer      ### df[3]
+          index = [index]
+        when Range        ### df["a".."d"]
+          if @row_index
+            idx1 = @row_index.search(index.begin)
+            idx2 = @row_index.search(index.end)
+            if idx1 and idx2
+              index = idx1..idx2
+            elsif index.begin.is_a?(Integer) || index.end.is_a?(Integer)
+              iloc[*argv]
+            else
+              raise "invalid index '#{index}'"
+            end
+          end
+        when Array
+          if index[0].is_a?(Range)
+            if @row_index
+              range = index[0]
+              idx1 = @row_index.search(range.begin)
+              idx2 = @row_index.search(range.end)
+              if idx1 and idx2
+                range = idx1..idx2
+              elsif range.begin.is_a?(Integer) || range.end.is_a?(Integer)
+              else
+                raise "invalid index '#{index}'"
+              end
+              index[0] = range
+            end            
+          end
+        else
+          if @row_index
+            idx1 = @row_index.search(index)
+            if idx1
+              index = [idx1]
+            else
+              raise "invalid index '#{index}'"
+            end
+          end
+        end
+        column_selector = select_columns(argv[1])
+        columns = {}
+        column_selector.each do |name|
+          columns[name] = @column_data[name][index] ### df[...]
+        end
+        return CADataFrame.new(columns, index: @row_index ? @row_index[index] : nil)
+      }
+    end
+
+    def []= (*argv)
+      value = argv.pop
+      @dataframe.instance_eval {
+        index = argv.first
+        case index
+        when nil
+        when CArray          
+        when Range         ### df["a".."d"] = value
+          if @row_index
+            idx1 = @row_index.search(index.begin)
+            idx2 = @row_index.search(index.end)
+            if idx1 and idx2
+              index = idx1..idx2
+            elsif index.begin.is_a?(Integer) || index.end.is_a?(Integer)
+              iloc[*argv] = value
+              return
+            else
+              raise "invalid index '#{index}'"
+            end
+          end
+        when Array
+          if index[0].is_a?(Range)
+            if @row_index
+              range = index[0]
+              idx1 = @row_index.search(range.begin)
+              idx2 = @row_index.search(range.end)
+              if idx1 and idx2
+                range = idx1..idx2
+              elsif range.begin.is_a?(Integer) || range.end.is_a?(Integer)
+              else
+                raise "invalid index '#{index}'"
+              end
+              index[0] = range
+            end            
+          end
+        else
+          if @row_index
+            idx1 = @row_index.search(index)
+            if idx1
+              index = [idx1]
+            else
+              raise "invalid index '#{index}'"
+            end
+          end
+        end
+        column_selector = select_columns(argv[1])
+        case value
+        when Hash          ### value = {"a"=> [1,2,3], ... }
+          value = value.map{|k,v| [k.to_s, v]}.to_h
+          column_selector.each do |name|
+            @column_data[name][index] = value[name]
+          end
+        when Array
+          case value.first
+          when Hash        ### value = [{"a"=>1,"b"=>11}, {"a"=>2,""=>12} ...]
+            table = {}
+            column_selector.each do |name|
+              table[name] = []
+            end
+            value.each do |hash|
+              hash = hash.map{|k,v| [k.to_s, v]}.to_h
+              column_selector.each do |name|
+                table[name] << hash[name]
+              end
+            end
+            column_selector.each do |name|
+              @column_data[name][index] = table[name]
+            end
+          else             ### value = [[1,11],[2,12],...]
+            value = value.transpose
+            column_selector.each_with_index do |name, k|
+              @column_data[name][index] = value[k]
+            end
+          end
+        else               ### value = any value
+          column_selector.each_with_index do |name, k|
+            @column_data[name][index] = value
+          end
+        end
+      }
+    end
+  end
+end

data/lib/carray-dataframe/pivot.rb

@@ -0,0 +1,54 @@
+#############################################################
+#
+# PIVOT TABLE
+#
+#############################################################
+class CADataFrame
+
+  def pivot (name1, name2)
+    return CADataFramePivot.new(self, name1, name2)
+  end
+end
+class CADataFramePivot
+
+  def initialize (dataframe, name1, name2)
+    @dataframe = dataframe
+    case name1
+    when Hash
+      name1, list = name1.first
+      @column1 = @dataframe.col(name1)
+      @keys1 = list.to_ca
+    else
+      @column1 = @dataframe.col(name1)
+      @keys1 = @column1.uniq.sort
+    end
+    case name2
+    when Hash
+      name2, list = name2.first
+      @column2 = @dataframe.col(name2)
+      @keys2 = list
+    else
+      @column2 = @dataframe.col(name2)
+      @keys2 = @column2.uniq.sort
+    end
+    @addrs = {}
+    @keys1.each do |k1|
+      @keys2.each do |k2|
+        @addrs[[k1,k2]] = (@column1.eq(k1) & @column2.eq(k2)).where
+      end
+    end
+  end
+
+  def table (&block)
+    columns = {}
+    @keys2.each do |k2|
+      columns[k2] = CArray.object(@keys1.size) { UNDEF }
+    end
+    @keys1.each_with_index do |k1, i|
+      @keys2.each do |k2|
+        columns[k2][i] = block.call(@dataframe[@addrs[[k1,k2]]])
+      end
+    end
+    return CADataFrame.new(columns, index: @keys1)
+  end
+end

data/lib/carray-dataframe/reference.rb

@@ -0,0 +1,142 @@
+
+class CADataFrame
+
+  def select_columns (selector = nil)
+    case selector
+    when nil                       ### all
+      return @column_names
+    when Integer
+      name = @column_names[selector]
+      raise "invalid column index" unless selector
+      return [name]
+    when String, Symbol            ### "AAA"
+      if @column_names.include?(selector.to_s)
+        return [selector.to_s]
+      else
+        raise "invalid column specified #{selector}"
+      end
+    when Array                     ### ["AAA", "BBB"]
+      if selector.size == 1 && selector.first.is_a?(Hash)
+        return select_columns(selector.first)
+      else
+        selector.each do |name|
+          unless @column_names.include?(name.to_s)
+            raise "invalid column specified #{name}"
+          end
+        end
+        return selector.map(&:to_s)
+      end
+    when Range                     ### "AAA".."BBB", 0..1
+      case selector.begin
+      when nil
+        idx1 = 0
+      when Integer
+        idx1 = selector.begin
+      when String, Symbol
+        idx1 = @column_names.search(selector.begin.to_s)
+        raise "can't find column #{selector.begin}" unless idx1
+      else
+        raise "invalid column specified #{selector.begin}"
+      end
+      if selector.exclude_end?
+        case selector.end
+        when nil
+          idx2 = -2
+        when Integer
+          idx2 = selector.end - 1
+        when String
+          idx2 = @column_names.search(selector.end.to_s) 
+          raise "can't find column #{selector.end}" unless idx2
+          idx2 = idx2 - 1
+        else
+          raise "invalid column specified #{selector.end}"
+        end        
+      else
+        case selector.end
+        when nil
+          idx2 = -1
+        when Integer
+          idx2 = selector.end
+        when String
+          idx2 = @column_names.search(selector.end.to_s)
+          raise "can't find column #{selector.end}" unless idx2
+        else
+          raise "invalid column specified #{selector.end}"
+        end
+      end
+      return @column_names[idx1..idx2]
+    else
+      raise "invalid column selector #{selector}"              
+    end
+  end
+
+  def [] (arg, opt = :__dummy__)
+    if opt != :__dummy__
+      return loc[arg, opt]
+    else
+      case arg
+      when Range
+        if arg.begin.is_a?(Integer)
+          return iloc[arg] unless @row_index
+        end
+        return loc[arg]
+      when CArray
+        if arg.rank == 1
+          return loc[arg]
+        else
+          raise "index should be 1-dim array"
+        end
+      when String, Symbol
+        return column(arg.to_s)
+      else
+        column_selector = select_columns(arg)
+        new_columns = {}
+        column_selector.each do |key|
+          new_columns[key] = @column_data[key]
+        end
+        return CADataFrame.new(new_columns, index: @row_index)
+      end
+    end
+  end
+
+  def []= (arg, opt = :__dummy__, value)
+    if opt != :__dummy__
+      loc[arg, opt] = value
+    else
+      case arg
+      when Range
+        if arg.begin.is_a?(Integer)
+          iloc[arg] = value unless @row_index
+        end
+        loc[arg] = value
+      when CArray
+        loc[arg] = value
+      when String, Symbol
+        if column(arg.to_s)
+          column(arg.to_s)[] = value
+        else
+          arrange {
+            append arg, value
+          }
+        end
+      else
+        case value
+        when CADataFrame
+          column_selector = select_columns(arg)
+          values = column_selector.each_index.map { |i| 
+            value.column(i).to_ca
+          }
+          column_selector.each_with_index do |key, i|
+            column(key)[] = values[i]
+          end
+        else
+          column_selector = select_columns(arg)
+          column_selector.each do |key|
+            column(key)[] = value
+          end        
+        end
+      end
+    end
+  end
+  
+end

data/lib/carray-dataframe/to_html.rb

@@ -0,0 +1,102 @@
+class CADataFrame
+
+  def to_html (threshold = 8, time_format: nil, index: true)
+    columns = @column_data.clone
+    @column_names.each do |name|
+      if columns[name].is_a?(CATimeIndex)
+        if time_format
+          columns[name] = columns[name].time.time_strftime(time_format)
+        else
+          columns[name] = columns[name].time.time_format("%F %T%:z")
+        end
+      end
+    end
+    if index
+      if @row_index
+        namelist = ["    "] + @column_names
+        if @row_index.is_a?(CATimeIndex)
+          if time_format
+            row_index = @row_index.time.time_strftime(time_format)
+          else
+            row_index = @row_index.time.time_format("%F %T%:z")
+          end
+        else
+          row_index = @row_index
+        end
+        tbl = CADFArray.new(namelist, columns.update("    " => row_index))
+      else
+        namelist = ["    "] + @column_names
+        tbl = CADFArray.new(namelist, columns.update("    " => CArray.int(@row_number).seq))
+      end
+    else
+      namelist = @column_names
+      tbl = CADFArray.new(namelist, columns)
+    end
+    if threshold.is_a?(Integer) and @row_number > threshold
+      list = tbl[0..(threshold/2),nil].to_a
+      list.push namelist.map { "..." }
+      list.push *(tbl[-threshold/2+1..-1,nil].to_a)
+      tbl = list.to_ca
+    end
+    datastr = tbl.convert {|c| __obj_to_string__(c) }.unmask("")
+    datamb  = datastr.convert(:boolean, &:"ascii_only?").not.sum(0).ne(0)
+    namemb  = namelist.to_ca.convert(:boolean) {|c| c.to_s.ascii_only? }.eq(0)
+    mb      = datamb.or(namemb)
+    namelen = namelist.map(&:length).to_ca
+    datalen = datastr.convert(&:length)
+    if mb.max == 0
+      if datalen.size == 0
+        lengths  = namelen.to_a
+      else
+        lengths  = datalen.max(0).pmax(namelen).to_a
+      end
+      table_in = "<table>"
+      header = "<thead><tr>" +
+               [namelist, lengths].transpose.map{|name, len|
+                  "<th>#{name.to_s.ljust(len)}</th>"
+               }.join() + "</tr></thead>"
+      body_in = "<tbody>"
+      ary = [table_in, header, body_in]
+			if datalen.size > 0
+	      datastr[:i,nil].each_with_index do |blk, i|
+	        list = blk.flatten.to_a
+	        ary << "<tr>" + [list, lengths].transpose.map {|value, len|
+	                        "<td>#{value.ljust(len)}</td>"
+                       }.join() + "</tr>"
+	      end
+			end
+      ary << "</tbody>"
+      ary << "</table>"
+      return "DataFrame: rows#=#{@row_number}: \n" + ary.join("\n")
+    else
+      namewidth  = namelist.to_ca.convert{|c| __strwidth__(c.to_s) }
+      if datalen.size == 0
+        maxwidth   = namewidth
+      else
+        datawidth  = datastr.convert{|c| __strwidth__(c.to_s) }
+        maxwidth   = datawidth.max(0).pmax(namewidth)
+      end
+      len = maxwidth[:*,nil] - datawidth + datalen
+      table_in = "<table>"
+      header = "<thead><tr>" +
+               [namelist, maxwidth.to_a].transpose.map{|name, len|
+                 "<th>#{name.to_s.ljust(len-__strwidth__(name.to_s)+name.to_s.length)}</th>"
+               }.join() + "</tr></thead>"
+      body_in = "<tbody>"
+      ary = [table_in, header, body_in]
+			if datalen.size > 0
+	      datastr[:i,nil].each_with_addr do |blk, i|
+	        list = blk.flatten.to_a
+	        ary << "<tr>" + list.map.with_index {|value, j|
+                       
+	                          "<td>#{value.ljust(len[i,j])}</td>"
+                          }.join() + "</tr>"
+	      end
+			end
+      ary << "</tbody>"
+      ary << "</table>"
+      return "DataFrame: row#=#{@row_number}: \n" + ary.join("\n")
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carray-dataframe
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Hiroki Motoyoshi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-02 00:00:00.000000000 Z
+date: 2020-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carray
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: axlsx
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-description: "    Extension for realizing DataFrame of R in Ruby\n"
+description: "    DataFrame in Ruby\n"
 email: ''
 executables: []
 extensions: []
@@ -60,28 +60,24 @@ extra_rdoc_files: []
 files:
 - API.txt
 - README.md
+- Rakefile
 - carray-dataframe.gemspec
-- examples/R/fit.rb
-- examples/R/iris.rb
-- examples/R/japan_area.rb
-- examples/R/kyaku.rb
-- examples/group_by.rb
-- examples/hist.rb
-- examples/iris.rb
-- examples/map.rb
-- examples/match.rb
-- examples/test.xlsx
-- examples/test1.rb
-- examples/test2.rb
-- examples/test3.db
-- examples/test3.rb
-- examples/test3.xlsx
-- examples/to_excel.rb
-- lib/R.rb
-- lib/carray/autoload/autoload_dataframe_dataframe.rb
-- lib/carray/dataframe/dataframe.rb
+- lib/carray-dataframe.rb
+- lib/carray-dataframe/arranger.rb
+- lib/carray-dataframe/cadf_array.rb
+- lib/carray-dataframe/converter.rb
+- lib/carray-dataframe/dataframe.rb
+- lib/carray-dataframe/group.rb
+- lib/carray-dataframe/iloc_accessor.rb
+- lib/carray-dataframe/io.rb
+- lib/carray-dataframe/join.rb
+- lib/carray-dataframe/loc_accessor.rb
+- lib/carray-dataframe/pivot.rb
+- lib/carray-dataframe/reference.rb
+- lib/carray-dataframe/to_html.rb
 homepage: https://github.com/himotoyoshi/carray-dataframe
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -98,9 +94,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Extension for realizing DataFrame of R in Ruby
+summary: DataFrame in Ruby
 test_files: []